Changes in / [5802a4f:66f8528]


Ignore:
Files:
40 added
7 deleted
70 edited

Legend:

Unmodified
Added
Removed
  • .gitignore

    r5802a4f r66f8528  
    2929src/driver/cfa-cpp
    3030
    31 src/libcfa/builtins.cf
    32 src/libcfa/extras.cf
     31src/prelude/builtins.cf
     32src/prelude/extras.cf
    3333src/libcfa/libcfa-prelude.c
    3434
  • Jenkinsfile

    r5802a4f r66f8528  
    2323                //escapes the sandbox
    2424                //Also specify the compiler by hand
    25                 sh "./configure CXX=${currentCC.cpp_cc} CXXFLAGS=${flags} CFAFLAGS=${flags} --with-backend-compiler=${currentCC.cfa_backend_cc} --prefix=${install_dir} --enable-silent-rules --quiet"
     25                sh "./configure CXX=${currentCC.cpp_cc} ${flags} --with-backend-compiler=${currentCC.cfa_backend_cc} --prefix=${install_dir} --enable-silent-rules --quiet"
    2626
    2727                //Compile the project
     
    3333                dir ('src/tests') {
    3434                        if (full_build) {
    35                                 sh 'make all-tests'
     35                                sh 'make all-tests debug=yes'
     36                                sh 'make all-tests debug=no'
    3637                        }
    3738                        else {
     
    166167
    167168                                bIsFullBuild = isFullBuild == 'true'
    168                                 architectureFlag = buildArchitecture == '64-bit' ? '-m64' : (buildArchitecture == '32-bit' ? '-m32' : 'ERROR')
     169                                architectureFlag = ''
     170                                if (buildArchitecture == '64-bit') {
     171                                        architectureFlag = '--host=x86_64 CXXFLAGS="-m64" CFAFLAGS="-m64"'
     172                                } else if (buildArchitecture == '32-bit'){
     173                                        architectureFlag = '--host=i386 CXXFLAGS="-m32" CFAFLAGS="-m32"'
     174                                } else {
     175                                        architectureFlag = 'ERROR'
     176                                }
    169177
    170178                                echo "FULL BUILD = ${isFullBuild}\nArchitecture = ${buildArchitecture} (flag ${architectureFlag})"
  • Makefile.am

    r5802a4f r66f8528  
    1111## Created On       : Sun May 31 22:14:18 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Fri Jun 17 14:56:18 2016
    14 ## Update Count     : 13
     13## Last Modified On : Wed Dec 14 14:20:48 2016
     14## Update Count     : 15
    1515###############################################################################
    1616
    1717AUTOMAKE_OPTIONS = foreign              # do not require all the GNU file names
    18 SUBDIRS = src/driver src src/libcfa     # order important, src before libcfa because cfa-cpp used to build prelude
     18SUBDIRS = src/driver src src/prelude src/libcfa # order important, src before prelude because cfa-cpp used to build prelude
    1919EXTRA_DIST = Docs                       # non-source files
    2020BACKEND_CC = @BACKEND_CC@               # C compiler used to compile Cforall programs, versus C++ compiler used to build cfa command
  • Makefile.in

    r5802a4f r66f8528  
    3535PRE_UNINSTALL = :
    3636POST_UNINSTALL = :
     37build_triplet = @build@
     38host_triplet = @host@
    3739subdir = .
    3840DIST_COMMON = README $(am__configure_deps) $(srcdir)/Makefile.am \
    3941        $(srcdir)/Makefile.in $(srcdir)/config.h.in \
    4042        $(top_srcdir)/configure INSTALL automake/compile \
    41         automake/depcomp automake/install-sh automake/missing \
    42         automake/ylwrap
     43        automake/config.guess automake/config.sub automake/depcomp \
     44        automake/install-sh automake/missing automake/ylwrap
    4345ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    4446am__aclocal_m4_deps = $(top_srcdir)/configure.ac
     
    124126BACKEND_CC = @BACKEND_CC@               # C compiler used to compile Cforall programs, versus C++ compiler used to build cfa command
    125127CC = @CC@
     128CCAS = @CCAS@
     129CCASDEPMODE = @CCASDEPMODE@
     130CCASFLAGS = @CCASFLAGS@
    126131CCDEPMODE = @CCDEPMODE@
    127132CFA_BACKEND_CC = @CFA_BACKEND_CC@
     
    158163LIBS = @LIBS@
    159164LTLIBOBJS = @LTLIBOBJS@
     165MACHINE_TYPE = @MACHINE_TYPE@
    160166MAINT = @MAINT@
    161167MAKEINFO = @MAKEINFO@
     
    189195am__untar = @am__untar@
    190196bindir = @bindir@
     197build = @build@
    191198build_alias = @build_alias@
     199build_cpu = @build_cpu@
     200build_os = @build_os@
     201build_vendor = @build_vendor@
    192202builddir = @builddir@
    193203datadir = @datadir@
     
    196206dvidir = @dvidir@
    197207exec_prefix = @exec_prefix@
     208host = @host@
    198209host_alias = @host_alias@
     210host_cpu = @host_cpu@
     211host_os = @host_os@
     212host_vendor = @host_vendor@
    199213htmldir = @htmldir@
    200214includedir = @includedir@
     
    221235top_srcdir = @top_srcdir@
    222236AUTOMAKE_OPTIONS = foreign              # do not require all the GNU file names
    223 SUBDIRS = src/driver src src/libcfa     # order important, src before libcfa because cfa-cpp used to build prelude
     237SUBDIRS = src/driver src src/prelude src/libcfa # order important, src before prelude because cfa-cpp used to build prelude
    224238EXTRA_DIST = Docs                       # non-source files
    225239MAINTAINERCLEANFILES = lib/* bin/* src/examples/.deps/* src/tests/.deps/* src/tests/.out/*
  • aclocal.m4

    r5802a4f r66f8528  
    6060_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
    6161
     62# Figure out how to run the assembler.                      -*- Autoconf -*-
     63
     64# Copyright (C) 2001, 2003, 2004, 2005, 2006  Free Software Foundation, Inc.
     65#
     66# This file is free software; the Free Software Foundation
     67# gives unlimited permission to copy and/or distribute it,
     68# with or without modifications, as long as this notice is preserved.
     69
     70# serial 5
     71
     72# AM_PROG_AS
     73# ----------
     74AC_DEFUN([AM_PROG_AS],
     75[# By default we simply use the C compiler to build assembly code.
     76AC_REQUIRE([AC_PROG_CC])
     77test "${CCAS+set}" = set || CCAS=$CC
     78test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS
     79AC_ARG_VAR([CCAS],      [assembler compiler command (defaults to CC)])
     80AC_ARG_VAR([CCASFLAGS], [assembler compiler flags (defaults to CFLAGS)])
     81_AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl
     82])
     83
    6284# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
    6385
     
    113135# expand $ac_aux_dir to an absolute path
    114136am_aux_dir=`cd $ac_aux_dir && pwd`
     137])
     138
     139# AM_COND_IF                                            -*- Autoconf -*-
     140
     141# Copyright (C) 2008, 2010 Free Software Foundation, Inc.
     142#
     143# This file is free software; the Free Software Foundation
     144# gives unlimited permission to copy and/or distribute it,
     145# with or without modifications, as long as this notice is preserved.
     146
     147# serial 3
     148
     149# _AM_COND_IF
     150# _AM_COND_ELSE
     151# _AM_COND_ENDIF
     152# --------------
     153# These macros are only used for tracing.
     154m4_define([_AM_COND_IF])
     155m4_define([_AM_COND_ELSE])
     156m4_define([_AM_COND_ENDIF])
     157
     158
     159# AM_COND_IF(COND, [IF-TRUE], [IF-FALSE])
     160# ---------------------------------------
     161# If the shell condition COND is true, execute IF-TRUE, otherwise execute
     162# IF-FALSE.  Allow automake to learn about conditional instantiating macros
     163# (the AC_CONFIG_FOOS).
     164AC_DEFUN([AM_COND_IF],
     165[m4_ifndef([_AM_COND_VALUE_$1],
     166           [m4_fatal([$0: no such condition "$1"])])dnl
     167_AM_COND_IF([$1])dnl
     168if test -z "$$1_TRUE"; then :
     169  m4_n([$2])[]dnl
     170m4_ifval([$3],
     171[_AM_COND_ELSE([$1])dnl
     172else
     173  $3
     174])dnl
     175_AM_COND_ENDIF([$1])dnl
     176fi[]dnl
    115177])
    116178
  • configure

    r5802a4f r66f8528  
    616616YFLAGS
    617617YACC
     618am__fastdepCCAS_FALSE
     619am__fastdepCCAS_TRUE
     620CCASDEPMODE
     621CCASFLAGS
     622CCAS
    618623am__fastdepCC_FALSE
    619624am__fastdepCC_TRUE
     
    639644CXXFLAGS
    640645CXX
     646MACHINE_TYPE
     647host_os
     648host_vendor
     649host_cpu
     650host
     651build_os
     652build_vendor
     653build_cpu
     654build
    641655CFA_FLAGS
    642656CFA_LIBDIR
     
    644658CFA_INCDIR
    645659CFA_PREFIX
     660BUILD_NO_LIB_FALSE
     661BUILD_NO_LIB_TRUE
     662BUILD_DEBUG_FALSE
     663BUILD_DEBUG_TRUE
     664BUILD_RELEASE_FALSE
     665BUILD_RELEASE_TRUE
    646666CFA_BACKEND_CC
    647667BACKEND_CC
     
    720740enable_maintainer_mode
    721741with_backend_compiler
     742enable_target_release
     743enable_target_debug
    722744enable_dependency_tracking
    723745'
     
    733755CC
    734756CFLAGS
     757CCAS
     758CCASFLAGS
    735759YACC
    736760YFLAGS
     
    13391363  --program-suffix=SUFFIX            append SUFFIX to installed program names
    13401364  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
     1365
     1366System types:
     1367  --build=BUILD     configure for building on BUILD [guessed]
     1368  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
    13411369_ACEOF
    13421370fi
     
    13561384  --disable-maintainer-mode  disable make rules and dependencies not useful
    13571385                          (and sometimes confusing) to the casual installer
     1386  --enable-target-release Build and install the release target
     1387  --enable-target-debug   Build and install the debug target
    13581388  --disable-dependency-tracking  speeds up one-time build
    13591389  --enable-dependency-tracking   do not reject slow dependency extractors
     
    13741404  CC          C compiler command
    13751405  CFLAGS      C compiler flags
     1406  CCAS        assembler compiler command (defaults to CC)
     1407  CCASFLAGS   assembler compiler flags (defaults to CFLAGS)
    13761408  YACC        The `Yet Another Compiler Compiler' implementation to use.
    13771409              Defaults to the first program found out of: `bison -y', `byacc',
     
    30793111
    30803112
     3113
     3114
     3115# Check whether --enable-target-release was given.
     3116if test "${enable_target_release+set}" = set; then :
     3117  enableval=$enable_target_release;
     3118fi
     3119
     3120# Check whether --enable-target-debug was given.
     3121if test "${enable_target_debug+set}" = set; then :
     3122  enableval=$enable_target_debug;
     3123fi
     3124
     3125
     3126case "$enable_target_release" in
     3127        yes)
     3128                case "$enable_target_debug" in
     3129                        yes)
     3130                                build_release="yes"
     3131                                build_debug="yes"
     3132                                ;;
     3133                        no)
     3134                                build_release="yes"
     3135                                build_debug="no"
     3136                                ;;
     3137                        *)
     3138                                build_release="yes"
     3139                                build_debug="no"
     3140                                ;;
     3141                esac
     3142                ;;
     3143        no)
     3144                case "$enable_target_debug" in
     3145                        yes)
     3146                                build_release="no"
     3147                                build_debug="yes"
     3148                                ;;
     3149                        no)
     3150                                build_release="no"
     3151                                build_debug="no"
     3152                                ;;
     3153                        *)
     3154                                build_release="no"
     3155                                build_debug="yes"
     3156                                ;;
     3157                esac
     3158                ;;
     3159        *)
     3160                case "$enable_target_debug" in
     3161                        yes)
     3162                                build_release="no"
     3163                                build_debug="yes"
     3164                                ;;
     3165                        no)
     3166                                build_release="yes"
     3167                                build_debug="no"
     3168                                ;;
     3169                        *)
     3170                                build_release="yes"
     3171                                build_debug="yes"
     3172                                ;;
     3173                esac
     3174                ;;
     3175esac
     3176
     3177 if test "x$build_release" = "xyes"; then
     3178  BUILD_RELEASE_TRUE=
     3179  BUILD_RELEASE_FALSE='#'
     3180else
     3181  BUILD_RELEASE_TRUE='#'
     3182  BUILD_RELEASE_FALSE=
     3183fi
     3184
     3185 if test "x$build_debug" = "xyes"; then
     3186  BUILD_DEBUG_TRUE=
     3187  BUILD_DEBUG_FALSE='#'
     3188else
     3189  BUILD_DEBUG_TRUE='#'
     3190  BUILD_DEBUG_FALSE=
     3191fi
     3192
     3193 if test "x$build_release$build_debug" = "xnono"; then
     3194  BUILD_NO_LIB_TRUE=
     3195  BUILD_NO_LIB_FALSE='#'
     3196else
     3197  BUILD_NO_LIB_TRUE='#'
     3198  BUILD_NO_LIB_FALSE=
     3199fi
     3200
     3201
    30813202if test "x$prefix" = "xNONE"; then
    30823203        cfa_prefix=${ac_default_prefix}
     
    31373258
    31383259CFA_FLAGS=${CFAFLAGS}
     3260
     3261
     3262# Make sure we can run config.sub.
     3263$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
     3264  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
     3265
     3266{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
     3267$as_echo_n "checking build system type... " >&6; }
     3268if ${ac_cv_build+:} false; then :
     3269  $as_echo_n "(cached) " >&6
     3270else
     3271  ac_build_alias=$build_alias
     3272test "x$ac_build_alias" = x &&
     3273  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
     3274test "x$ac_build_alias" = x &&
     3275  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
     3276ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
     3277  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
     3278
     3279fi
     3280{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
     3281$as_echo "$ac_cv_build" >&6; }
     3282case $ac_cv_build in
     3283*-*-*) ;;
     3284*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
     3285esac
     3286build=$ac_cv_build
     3287ac_save_IFS=$IFS; IFS='-'
     3288set x $ac_cv_build
     3289shift
     3290build_cpu=$1
     3291build_vendor=$2
     3292shift; shift
     3293# Remember, the first character of IFS is used to create $*,
     3294# except with old shells:
     3295build_os=$*
     3296IFS=$ac_save_IFS
     3297case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
     3298
     3299
     3300{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
     3301$as_echo_n "checking host system type... " >&6; }
     3302if ${ac_cv_host+:} false; then :
     3303  $as_echo_n "(cached) " >&6
     3304else
     3305  if test "x$host_alias" = x; then
     3306  ac_cv_host=$ac_cv_build
     3307else
     3308  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
     3309    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
     3310fi
     3311
     3312fi
     3313{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
     3314$as_echo "$ac_cv_host" >&6; }
     3315case $ac_cv_host in
     3316*-*-*) ;;
     3317*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
     3318esac
     3319host=$ac_cv_host
     3320ac_save_IFS=$IFS; IFS='-'
     3321set x $ac_cv_host
     3322shift
     3323host_cpu=$1
     3324host_vendor=$2
     3325shift; shift
     3326# Remember, the first character of IFS is used to create $*,
     3327# except with old shells:
     3328host_os=$*
     3329IFS=$ac_save_IFS
     3330case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
     3331
     3332
     3333MACHINE_TYPE=$host_cpu
    31393334
    31403335
     
    45034698  am__fastdepCC_TRUE='#'
    45044699  am__fastdepCC_FALSE=
     4700fi
     4701
     4702
     4703# By default we simply use the C compiler to build assembly code.
     4704
     4705test "${CCAS+set}" = set || CCAS=$CC
     4706test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS
     4707
     4708
     4709
     4710depcc="$CCAS"   am_compiler_list=
     4711
     4712{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
     4713$as_echo_n "checking dependency style of $depcc... " >&6; }
     4714if ${am_cv_CCAS_dependencies_compiler_type+:} false; then :
     4715  $as_echo_n "(cached) " >&6
     4716else
     4717  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
     4718  # We make a subdir and do the tests there.  Otherwise we can end up
     4719  # making bogus files that we don't know about and never remove.  For
     4720  # instance it was reported that on HP-UX the gcc test will end up
     4721  # making a dummy file named `D' -- because `-MD' means `put the output
     4722  # in D'.
     4723  rm -rf conftest.dir
     4724  mkdir conftest.dir
     4725  # Copy depcomp to subdir because otherwise we won't find it if we're
     4726  # using a relative directory.
     4727  cp "$am_depcomp" conftest.dir
     4728  cd conftest.dir
     4729  # We will build objects and dependencies in a subdirectory because
     4730  # it helps to detect inapplicable dependency modes.  For instance
     4731  # both Tru64's cc and ICC support -MD to output dependencies as a
     4732  # side effect of compilation, but ICC will put the dependencies in
     4733  # the current directory while Tru64 will put them in the object
     4734  # directory.
     4735  mkdir sub
     4736
     4737  am_cv_CCAS_dependencies_compiler_type=none
     4738  if test "$am_compiler_list" = ""; then
     4739     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
     4740  fi
     4741  am__universal=false
     4742
     4743
     4744  for depmode in $am_compiler_list; do
     4745    # Setup a source with many dependencies, because some compilers
     4746    # like to wrap large dependency lists on column 80 (with \), and
     4747    # we should not choose a depcomp mode which is confused by this.
     4748    #
     4749    # We need to recreate these files for each test, as the compiler may
     4750    # overwrite some of them when testing with obscure command lines.
     4751    # This happens at least with the AIX C compiler.
     4752    : > sub/conftest.c
     4753    for i in 1 2 3 4 5 6; do
     4754      echo '#include "conftst'$i'.h"' >> sub/conftest.c
     4755      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
     4756      # Solaris 8's {/usr,}/bin/sh.
     4757      touch sub/conftst$i.h
     4758    done
     4759    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
     4760
     4761    # We check with `-c' and `-o' for the sake of the "dashmstdout"
     4762    # mode.  It turns out that the SunPro C++ compiler does not properly
     4763    # handle `-M -o', and we need to detect this.  Also, some Intel
     4764    # versions had trouble with output in subdirs
     4765    am__obj=sub/conftest.${OBJEXT-o}
     4766    am__minus_obj="-o $am__obj"
     4767    case $depmode in
     4768    gcc)
     4769      # This depmode causes a compiler race in universal mode.
     4770      test "$am__universal" = false || continue
     4771      ;;
     4772    nosideeffect)
     4773      # after this tag, mechanisms are not by side-effect, so they'll
     4774      # only be used when explicitly requested
     4775      if test "x$enable_dependency_tracking" = xyes; then
     4776        continue
     4777      else
     4778        break
     4779      fi
     4780      ;;
     4781    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
     4782      # This compiler won't grok `-c -o', but also, the minuso test has
     4783      # not run yet.  These depmodes are late enough in the game, and
     4784      # so weak that their functioning should not be impacted.
     4785      am__obj=conftest.${OBJEXT-o}
     4786      am__minus_obj=
     4787      ;;
     4788    none) break ;;
     4789    esac
     4790    if depmode=$depmode \
     4791       source=sub/conftest.c object=$am__obj \
     4792       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
     4793       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
     4794         >/dev/null 2>conftest.err &&
     4795       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
     4796       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
     4797       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
     4798       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
     4799      # icc doesn't choke on unknown options, it will just issue warnings
     4800      # or remarks (even with -Werror).  So we grep stderr for any message
     4801      # that says an option was ignored or not supported.
     4802      # When given -MP, icc 7.0 and 7.1 complain thusly:
     4803      #   icc: Command line warning: ignoring option '-M'; no argument required
     4804      # The diagnosis changed in icc 8.0:
     4805      #   icc: Command line remark: option '-MP' not supported
     4806      if (grep 'ignoring option' conftest.err ||
     4807          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
     4808        am_cv_CCAS_dependencies_compiler_type=$depmode
     4809        break
     4810      fi
     4811    fi
     4812  done
     4813
     4814  cd ..
     4815  rm -rf conftest.dir
     4816else
     4817  am_cv_CCAS_dependencies_compiler_type=none
     4818fi
     4819
     4820fi
     4821{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CCAS_dependencies_compiler_type" >&5
     4822$as_echo "$am_cv_CCAS_dependencies_compiler_type" >&6; }
     4823CCASDEPMODE=depmode=$am_cv_CCAS_dependencies_compiler_type
     4824
     4825 if
     4826  test "x$enable_dependency_tracking" != xno \
     4827  && test "$am_cv_CCAS_dependencies_compiler_type" = gcc3; then
     4828  am__fastdepCCAS_TRUE=
     4829  am__fastdepCCAS_FALSE='#'
     4830else
     4831  am__fastdepCCAS_TRUE='#'
     4832  am__fastdepCCAS_FALSE=
    45054833fi
    45064834
     
    58566184
    58576185
    5858 ac_config_files="$ac_config_files Makefile src/driver/Makefile src/Makefile src/examples/Makefile src/tests/Makefile src/libcfa/Makefile"
     6186ac_config_files="$ac_config_files Makefile src/driver/Makefile src/Makefile src/examples/Makefile src/tests/Makefile src/prelude/Makefile src/libcfa/Makefile"
    58596187
    58606188
     
    59806308Usually this means the macro was only invoked conditionally." "$LINENO" 5
    59816309fi
     6310if test -z "${BUILD_RELEASE_TRUE}" && test -z "${BUILD_RELEASE_FALSE}"; then
     6311  as_fn_error $? "conditional \"BUILD_RELEASE\" was never defined.
     6312Usually this means the macro was only invoked conditionally." "$LINENO" 5
     6313fi
     6314if test -z "${BUILD_DEBUG_TRUE}" && test -z "${BUILD_DEBUG_FALSE}"; then
     6315  as_fn_error $? "conditional \"BUILD_DEBUG\" was never defined.
     6316Usually this means the macro was only invoked conditionally." "$LINENO" 5
     6317fi
     6318if test -z "${BUILD_NO_LIB_TRUE}" && test -z "${BUILD_NO_LIB_FALSE}"; then
     6319  as_fn_error $? "conditional \"BUILD_NO_LIB\" was never defined.
     6320Usually this means the macro was only invoked conditionally." "$LINENO" 5
     6321fi
    59826322if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
    59836323  as_fn_error $? "conditional \"AMDEP\" was never defined.
     
    59906330if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
    59916331  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
     6332Usually this means the macro was only invoked conditionally." "$LINENO" 5
     6333fi
     6334if test -z "${am__fastdepCCAS_TRUE}" && test -z "${am__fastdepCCAS_FALSE}"; then
     6335  as_fn_error $? "conditional \"am__fastdepCCAS\" was never defined.
    59926336Usually this means the macro was only invoked conditionally." "$LINENO" 5
    59936337fi
     
    66036947    "src/examples/Makefile") CONFIG_FILES="$CONFIG_FILES src/examples/Makefile" ;;
    66046948    "src/tests/Makefile") CONFIG_FILES="$CONFIG_FILES src/tests/Makefile" ;;
     6949    "src/prelude/Makefile") CONFIG_FILES="$CONFIG_FILES src/prelude/Makefile" ;;
    66056950    "src/libcfa/Makefile") CONFIG_FILES="$CONFIG_FILES src/libcfa/Makefile" ;;
    66066951
     
    73337678
    73347679
     7680if test -z "$BUILD_RELEASE_TRUE"; then :
     7681  if test -z "$BUILD_DEBUG_TRUE"; then :
     7682  { $as_echo "$as_me:${as_lineno-$LINENO}: Building libcfa for target: release & debug" >&5
     7683$as_echo "$as_me: Building libcfa for target: release & debug" >&6;}
     7684else
     7685  { $as_echo "$as_me:${as_lineno-$LINENO}: Building libcfa for target: release" >&5
     7686$as_echo "$as_me: Building libcfa for target: release" >&6;}
     7687fi
     7688else
     7689  if test -z "$BUILD_DEBUG_TRUE"; then :
     7690  { $as_echo "$as_me:${as_lineno-$LINENO}: Building libcfa for target: debug" >&5
     7691$as_echo "$as_me: Building libcfa for target: debug" >&6;}
     7692else
     7693  { $as_echo "$as_me:${as_lineno-$LINENO}: Running cfa without libcfa" >&5
     7694$as_echo "$as_me: Running cfa without libcfa" >&6;}
     7695fi
     7696fi
     7697
    73357698# Final text
    73367699{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Cforall configuraton completed. Type \"make -j 8 install\"." >&5
  • configure.ac

    r5802a4f r66f8528  
    5353AC_SUBST(CFA_BACKEND_CC)
    5454
     55
     56
     57AC_ARG_ENABLE(target-release, AS_HELP_STRING([--enable-target-release], [Build and install the release target]))
     58AC_ARG_ENABLE(target-debug, AS_HELP_STRING([--enable-target-debug], [Build and install the debug target]))
     59
     60case "$enable_target_release" in
     61        yes)
     62                case "$enable_target_debug" in
     63                        yes)
     64                                build_release="yes"
     65                                build_debug="yes"
     66                                ;;
     67                        no)
     68                                build_release="yes"
     69                                build_debug="no"
     70                                ;;
     71                        *)
     72                                build_release="yes"
     73                                build_debug="no"
     74                                ;;
     75                esac
     76                ;;
     77        no)
     78                case "$enable_target_debug" in
     79                        yes)
     80                                build_release="no"
     81                                build_debug="yes"
     82                                ;;
     83                        no)
     84                                build_release="no"
     85                                build_debug="no"
     86                                ;;
     87                        *)
     88                                build_release="no"
     89                                build_debug="yes"
     90                                ;;
     91                esac
     92                ;;
     93        *)
     94                case "$enable_target_debug" in
     95                        yes)
     96                                build_release="no"
     97                                build_debug="yes"
     98                                ;;
     99                        no)
     100                                build_release="yes"
     101                                build_debug="no"
     102                                ;;
     103                        *)
     104                                build_release="yes"
     105                                build_debug="yes"
     106                                ;;
     107                esac
     108                ;;
     109esac
     110
     111AM_CONDITIONAL([BUILD_RELEASE], [test "x$build_release" = "xyes"])
     112AM_CONDITIONAL([BUILD_DEBUG], [test "x$build_debug" = "xyes"])
     113AM_CONDITIONAL([BUILD_NO_LIB], [test "x$build_release$build_debug" = "xnono"])
     114
    55115if test "x$prefix" = "xNONE"; then
    56116        cfa_prefix=${ac_default_prefix}
     
    87147AC_DEFINE_UNQUOTED(CFA_FLAGS, "${CFAFLAGS}", [compilation flags for cfa libraries and test programs.])
    88148AC_SUBST(CFA_FLAGS, ${CFAFLAGS})
     149
     150AC_CANONICAL_HOST
     151AC_SUBST([MACHINE_TYPE],[$host_cpu])
    89152
    90153# Checks for programs.
    91154AC_PROG_CXX
    92155AC_PROG_CC
     156AM_PROG_AS
    93157AM_PROG_CC_C_O  # deprecated
    94158# These are often not installed and people miss seeing the "no", so stop the configure.
     
    128192        src/examples/Makefile
    129193        src/tests/Makefile
     194        src/prelude/Makefile
    130195        src/libcfa/Makefile
    131196        ])
     
    133198AC_OUTPUT
    134199
     200AM_COND_IF([BUILD_RELEASE],
     201        [AM_COND_IF([BUILD_DEBUG],
     202                [AC_MSG_NOTICE(Building libcfa for target: release & debug)],
     203                [AC_MSG_NOTICE(Building libcfa for target: release)])],
     204        [AM_COND_IF([BUILD_DEBUG],
     205                [AC_MSG_NOTICE(Building libcfa for target: debug)],
     206                [AC_MSG_NOTICE(Running cfa without libcfa)])])
     207
    135208# Final text
    136209AC_MSG_RESULT(Cforall configuraton completed. Type "make -j 8 install".)
  • doc/proposals/concurrency/Makefile

    r5802a4f r66f8528  
    99SOURCES = ${addsuffix .tex, \
    1010concurrency \
     11style \
     12glossary \
    1113}
    1214
  • doc/proposals/concurrency/concurrency.tex

    r5802a4f r66f8528  
    11% requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
    22
    3 % inline code �...� (copyright symbol) emacs: C-q M-)
    4 % red highlighting �...� (registered trademark symbol) emacs: C-q M-.
    5 % blue highlighting �...� (sharp s symbol) emacs: C-q M-_
    6 % green highlighting �...� (cent symbol) emacs: C-q M-"
    7 % LaTex escape �...� (section symbol) emacs: C-q M-'
    8 % keyword escape �...� (pilcrow symbol) emacs: C-q M-^
     3% inline code ©...© (copyright symbol) emacs: C-q M-)
     4% red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
     5% blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
     6% green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
     7% LaTex escape §...§ (section symbol) emacs: C-q M-'
     8% keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
    99% math escape $...$ (dollar symbol)
    1010
     
    100100
    101101\section{Introduction}
    102 This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible concurrency core is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency in \CFA. Indeed, for highly productive parallel programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based parallelism, message passing and implicit threading.
    103 
    104 There are actually two problems that need to be solved in the design of the concurrency for a programming language. Which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are more about performance, cost and resource utilization.
     102This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible concurrency core is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency in \CFA. Indeed, for highly productive parallel programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading.
     103
     104There are actually two problems that need to be solved in the design of the concurrency for a programming language: which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are more about performance, cost and resource utilization.
    105105
    106106%  #####  ####### #     #  #####  #     # ######  ######  ####### #     #  #####  #     #
     
    113113
    114114\section{Concurrency}
    115 Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts. However, in languages that use routine calls as their core abstraction mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. This distinction can be hidden away in library code, but effective use of the librairy will still have to take both paradigms into account. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm~\cite{HPP:Study}. An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be possible to add such a paradigm to a language like C or \CC\cit, which is why it was rejected as the core paradigm for concurrency in \CFA. One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes Monitors as the core concurrency construct.
     115Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). Which in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. This distinction can be hidden away in library code, but effective use of the librairy still has to take both paradigms into account. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}. An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to add such a paradigm to a language like C or \CC\cit, which is why it was rejected as the core paradigm for concurrency in \CFA. One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency construct.
    116116
    117117% #     # ####### #     # ### ####### ####### ######   #####
     
    144144
    145145\subsubsection{Call semantics} \label{call}
    146 The above monitor example displays some of their intrinsic characteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because at their core, monitors are implicit mutual-exclusion objects (locks), and these objects cannot be copied. Therefore, monitors are implicitly non-copyable.
    147 
    148 Another aspect to consider is when a monitor acquires its mutual exclusion. For example, a monitor may need to be passed through multiple helper routines that do not acquire the monitor mutual exclusion on entry. Pass through can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following to implement an atomic large counter :
    149 
    150 \begin{lstlisting}
    151         mutex struct counter_t { /*...*/ };
    152 
    153         void ?{}(counter_t & nomutex this);
    154         size_t ++?(counter_t & mutex this);
     146The above monitor example displays some of the intrinsic characteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because at their core, monitors are implicit mutual-exclusion objects (locks), and these objects cannot be copied. Therefore, monitors are implicitly non-copyable.
     147
     148Another aspect to consider is when a monitor acquires its mutual exclusion. For example, a monitor may need to be passed through multiple helper routines that do not acquire the monitor mutual-exclusion on entry. Pass through can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following to implement an atomic counter :
     149
     150\begin{lstlisting}
     151        mutex struct counter_t { /*...see section §\ref{data}§...*/ };
     152
     153        void ?{}(counter_t & nomutex this); //constructor
     154        size_t ++?(counter_t & mutex this); //increment
    155155
    156156        //need for mutex is platform dependent here
    157         void ?{}(size_t * this, counter_t & mutex cnt);
    158 \end{lstlisting}
    159 *semantics of the declaration of \code{mutex struct counter_t} are discussed in details in section \ref{data}
    160 
    161 Here, the constructor(\code(?{})) uses the \code{nomutex} keyword to signify that it does not acquire the monitor mutual exclusion when constructing. This semantics is because object not yet constructed should never be shared and therefore do not require mutual exclusion. The prefix increment operator uses \code{mutex} to protect the incrementing process from race conditions. Finally, there is a conversion operator from \code{counter_t} to \code{size_t}. This conversion may or may not require the \code{mutex} key word depending on whether or not reading an \code{size_t} is an atomic operation or not.
    162 
    163 Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. If there were a meaning to routine \code{void foo(counter_t & this)} then one could argue that it should default to the safest option : \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that this is the more "normal" behavior, \code{nomutex} effectively stating explicitly that "this routine has nothing special". Another alternative is to make having exactly one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being self-documented but at the cost of extra typing. In the end, which solution should be picked is still up for debate. For the reminder of this proposal, the explicit approach is used for clarity.
    164 
    165 Regardless of which keyword is kept, it is important to establish when mutex/nomutex may be used as a type qualifier. Consider :
     157        void ?{}(size_t * this, counter_t & mutex cnt); //conversion
     158\end{lstlisting}
     159
     160Here, the constructor(\code{?\{\}}) uses the \code{nomutex} keyword to signify that it does not acquire the monitor mutual exclusion when constructing. This semantics is because an object not yet constructed should never be shared and therefore does not require mutual exclusion. The prefix increment operator uses \code{mutex} to protect the incrementing process from race conditions. Finally, there is a conversion operator from \code{counter_t} to \code{size_t}. This conversion may or may not require the \code{mutex} key word depending on whether or not reading an \code{size_t} is an atomic operation or not.
     161
     162Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without wualifiers \code{void foo(counter_t & this)} then one could argue that it should default to the safest option \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that \code{nomutex} is the more "normal" behaviour, the \code{nomutex} keyword effectively stating explicitly that "this routine has nothing special". Another alternative is to make having exactly one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being self-documented but at the cost of extra typing. In the end, which solution should be picked is still up for debate. For the reminder of this proposal, the explicit approach is used for clarity.
     163
     164The next semantic decision is to establish when mutex/nomutex may be used as a type qualifier. Consider the following declarations:
    166165\begin{lstlisting}
    167166        int f1(monitor & mutex m);
     
    171170        int f5(graph(monitor*) & mutex m);
    172171\end{lstlisting}
    173 
    174 The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entering. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter (ignoring potential qualifiers and indirections). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} will be acquired, passing an array to this routine would be type safe and result in undefined behavior. For this reason, it would also be reasonnable to disallow mutex in the context where arrays may be passed.
     172The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter (ignoring potential qualifiers and indirections). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. However, this ambiguity is part of the C type system with respects to arrays. For this reason, it would also be reasonnable to disallow mutex in the context where arrays may be passed.
    175173
    176174% ######     #    #######    #
     
    183181
    184182\subsubsection{Data semantics} \label{data}
    185 Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contian shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appripriate protection. For example here is a more fleshed-out version of the counter showed in \ref{call}:
     183Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contian shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appropriate protection. For example, here is a complete version of the counter showed in section \ref{call}:
    186184\begin{lstlisting}
    187185        mutex struct counter_t {
     
    203201\end{lstlisting}
    204202
    205 This simple counter offers an example of monitor usage. Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting :
     203This simple counter is used as follows:
    206204\begin{center}
    207205\begin{tabular}{c @{\hskip 0.35in} c @{\hskip 0.35in} c}
    208206\begin{lstlisting}
     207        //shared counter
    209208        counter_t cnt;
    210209
     210        //multiple threads access counter
    211211        thread 1 : cnt++;
    212212        thread 2 : cnt++;
     
    218218\end{center}
    219219
    220 These simple mutual exclusion semantics also naturally expand to multi-monitor calls.
     220Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting. Unlike object-oriented monitors, where calling a mutex member \emph{implicitly} acquires mutual-exclusion, \CFA uses an explicit mechanism to acquire mutual-exclusion. A consequence of this approach is that it extends to multi-monitor calls.
    221221\begin{lstlisting}
    222222        int f(MonitorA & mutex a, MonitorB & mutex b);
     
    226226        f(a,b);
    227227\end{lstlisting}
    228 
    229 This code acquires both locks before entering the critical section (Referenced as \gls{group-acquire} from now on). In practice, writing multi-locking routines that can not lead to deadlocks can be tricky. Having language support for such a feature is therefore a significant asset for \CFA. In the case presented above, \CFA guarantees that the order of aquisition will be consistent across calls to routines using the same monitors as arguments. However, since \CFA monitors use multi-acquiring locks users can effectively force the acquiring order. For example, notice which routines use \code{mutex}/\code{nomutex} and how this affects aquiring order :
    230 \begin{lstlisting}
    231         void foo(A & mutex a, B & mutex a) {
    232                 //...
    233         }
    234 
    235         void bar(A & mutex a, B & nomutex a)
    236                 //...
    237                 foo(a, b);
    238                 //...
    239         }
    240 
    241         void baz(A & nomutex a, B & mutex a)
    242                 //...
    243                 foo(a, b);
    244                 //...
    245         }
    246 \end{lstlisting}
    247 
    248 Such a use will lead to nested monitor call problems~\cite{Lister77}, which are a specific implementation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlocks, depending on the implicit ordering matching the explicit ordering. As shown on several occasion\cit, solving this problems requires to :
     228This code acquires both locks before entering the critical section, called \emph{\gls{group-acquire}}. In practice, writing multi-locking routines that do not lead to deadlocks is tricky. Having language support for such a feature is therefore a significant asset for \CFA. In the case presented above, \CFA guarantees that the order of aquisition is consistent across calls to routines using the same monitors as arguments. However, since \CFA monitors use multi-acquisition locks, users can effectively force the acquiring order. For example, notice which routines use \code{mutex}/\code{nomutex} and how this affects aquiring order :
     229\begin{lstlisting}
     230        void foo(A & mutex a, B & mutex b) { //acquire a & b
     231                //...
     232        }
     233
     234        void bar(A & mutex a, B & nomutex b) { //acquire a
     235                //...
     236                foo(a, b); //acquire b
     237                //...
     238        }
     239
     240        void baz(A & nomutex a, B & mutex b) { //acquire b
     241                //...
     242                foo(a, b); //acquire a
     243                //...
     244        }
     245\end{lstlisting}
     246
     247The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order. such use leads to nested monitor call problems~\cite{Lister77}, which is a specific implementation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires :
    249248\begin{enumerate}
    250         \item Dynamically track the monitor call order.
     249        \item Dynamically tracking of the monitor-call order.
    251250        \item Implement rollback semantics.
    252251\end{enumerate}
    253252
    254 While the first requirement is already a significant constraint on the system, implementing a general rollback semantics in a C-like language is prohibitively complex \cit. In \CFA users simply need to be carefull when acquiring multiple monitors at the same time.
     253While the first requirement is already a significant constraint on the system, implementing a general rollback semantics in a C-like language is prohibitively complex \cit. In \CFA, users simply need to be carefull when acquiring multiple monitors at the same time.
    255254
    256255% ######  ####### #######    #    ### #        #####
     
    271270
    272271\subsubsection{Implementation Details: Interaction with polymorphism}
    273 At first glance, interaction between monitors and \CFA's concept of polymorphism seem complex to support. However, it can be reasoned that entry-point locking can solve most of the issues that could be present with polymorphism.
    274 
    275 First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. \Gls{callsite-locking}\footnotemark would require a significant amount of work, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking}\footnotemark[\value{footnote}] calling a monitor routine becomes exactly the same as calling it from anywhere else.
    276 \footnotetext{See glossary for a definition of \gls{callsite-locking} and \gls{entry-point-locking}}
     272At first glance, interaction between monitors and \CFA's concept of polymorphism seems complex to support. However, it is shown that entry-point locking can solve most of the issues.
     273
     274Before looking into complex control flow, it is important to present the difference between the two acquiring options : \gls{callsite-locking} and \gls{entry-point-locking}, i.e. acquiring the monitors before making a mutex call or as the first instruction of the mutex call. For example:
     275
     276\begin{center}
     277\begin{tabular}{|c|c|c|}
     278Code & \gls{callsite-locking} & \gls{entry-point-locking} \\
     279\CFA & pseudo-code & pseudo-code \\
     280\hline
     281\begin{lstlisting}
     282void foo(monitor & mutex a) {
     283
     284
     285
     286        //Do Work
     287        //...
     288
     289}
     290
     291void main() {
     292        monitor a;
     293
     294
     295
     296        foo(a);
     297
     298}
     299\end{lstlisting} &\begin{lstlisting}
     300foo(& a) {
     301
     302
     303
     304        //Do Work
     305        //...
     306
     307}
     308
     309main() {
     310        monitor a;
     311        //calling routine
     312        //handles concurrency
     313        acquire(a);
     314        foo(a);
     315        release(a);
     316}
     317\end{lstlisting} &\begin{lstlisting}
     318foo(& a) {
     319        //called routine
     320        //handles concurrency
     321        acquire(a);
     322        //Do Work
     323        //...
     324        release(a);
     325}
     326
     327main() {
     328        monitor a;
     329
     330
     331
     332        foo(a);
     333
     334}
     335\end{lstlisting}
     336\end{tabular}
     337\end{center}
     338
     339First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. \Gls{callsite-locking} would require a significant amount of work, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else.
     340
     341
    277342
    278343% ### #     # #######         #####   #####  #     # ####### ######
     
    285350
    286351\subsection{Internal scheduling} \label{insched}
    287 Monitors also need to schedule waiting threads within it as a mean of synchronization. Internal scheduling is one of the simple examples of such a feature. It allows users to declare condition variables and have threads wait and signaled from them. Here is a simple example of such a technique :
     352Monitors also need to schedule waiting threads internally as a mean of synchronization. Internal scheduling is one of the simple examples of such a feature. It allows users to declare condition variables and have threads wait and signaled from them. Here is a simple example of such a technique :
    288353
    289354\begin{lstlisting}
     
    303368\end{lstlisting}
    304369
    305 Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. This semantic can easily be extended to multi-monitor calls by offering the same guarantee.
     370Note that in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. This semantic can easily be extended to multi-monitor calls by offering the same guarantee.
    306371\begin{center}
    307372\begin{tabular}{ c @{\hskip 0.65in} c }
     
    337402condition e;
    338403
     404//acquire a & b
    339405void foo(monitor & mutex a,
    340406           monitor & mutex b) {
    341407
    342         wait(e);
     408        wait(e); //release a & b
    343409}
    344410
     
    352418condition e;
    353419
     420//acquire a
    354421void bar(monitor & mutex a,
    355422           monitor & nomutex b) {
     
    357424}
    358425
     426//acquire a & b
    359427void foo(monitor & mutex a,
    360428           monitor & mutex b) {
    361         wait(e);
     429        wait(e);  //release a & b
    362430}
    363431
     
    366434condition e;
    367435
     436//acquire a
    368437void bar(monitor & mutex a,
    369438           monitor & nomutex b) {
     
    371440}
    372441
     442//acquire b
    373443void baz(monitor & nomutex a,
    374444           monitor & mutex b) {
    375         wait(e);
     445        wait(e);  //release b
    376446}
    377447
     
    381451\end{center}
    382452
    383 Note that in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Context 1 is the simplest way of acquiring more than one monitor (\gls{group-acquire}), using a routine wiht multiple parameters having the \code{mutex} keyword. Context 2 also uses \gls{group-acquire} as well in routine \code{foo}. However, the routine is called by routine \code{bar} which only acquires monitor \code{a}. Since monitors can be acquired multiple times this will not cause a deadlock by itself but it does force the acquiring order to \code{a} then \code{b}. Context 3 also forces the acquiring order to be \code{a} then \code{b} but does not use \gls{group-acquire}. The previous example tries to illustrate the semantics that must be established to support releasing monitors in a \code{wait} statement. In all cases the behavior of the wait statment is to release all the locks that were acquired my the inner-most monitor call. That is \code{a & b} in context 1 and 2 and \code{b} only in context 3. Here are a few other examples of this behavior.
     453Context 1 is the simplest way of acquiring more than one monitor (\gls{group-acquire}), using a routine with multiple parameters having the \code{mutex} keyword. Context 2 also uses \gls{group-acquire} as well in routine \code{foo}. However, the routine is called by routine \code{bar}, which only acquires monitor \code{a}. Since monitors can be acquired multiple times this does not cause a deadlock by itself but it does force the acquiring order to \code{a} then \code{b}. Context 3 also forces the acquiring order to be \code{a} then \code{b} but does not use \gls{group-acquire}. The previous example tries to illustrate the semantics that must be established to support releasing monitors in a \code{wait} statement. In all cases, the behavior of the wait statment is to release all the locks that were acquired my the inner-most monitor call. That is \code{a & b} in context 1 and 2 and \code{b} only in context 3. Here are a few other examples of this behavior.
    384454
    385455
     
    389459condition e;
    390460
    391 //acquire a
     461//acquire b
    392462void foo(monitor & nomutex a,
    393463           monitor & mutex b) {
     
    399469           monitor & nomutex b) {
    400470
    401         //release a
    402         //keep b
    403         wait(e);
     471        wait(e); //release a
     472                  //keep b
    404473}
    405474
     
    418487           monitor & nomutex b) {
    419488
    420         //release b
    421         //keep a
    422         wait(e);
     489        wait(e); //release b
     490                  //keep a
    423491}
    424492
     
    437505           monitor & nomutex b) {
    438506
    439         //release a & b
    440         //keep none
    441         wait(e);
     507        wait(e); //release a & b
     508                  //keep none
    442509}
    443510
     
    446513\end{tabular}
    447514\end{center}
    448 Note the right-most example which uses a helper routine and therefore is not relevant to find which monitors will be released.
    449 
    450 These semantics imply that in order to release of subset of the monitors currently held, users must write (and name) a routine that only acquires the desired subset and simply calls wait. While users can use this method, \CFA offers the \code{wait_release}\footnote{Not sure if an overload of \code{wait} would work...} which will release only the specified monitors.
    451 
    452 Regardless of the context in which the \code{wait} statement is used, \code{signal} must used holding the same set of monitors. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) that call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor.
     515Note the right-most example is actually a trick pulled on the reader. Monitor state information is stored in thread local storage rather then in the routine context, which means that helper routines and other \code{nomutex} routines are invisible to the runtime system in regards to concurrency. This means that in the right-most example, the routine parameters are completly unnecessary. However, calling this routine from outside a valid monitor context is undefined.
     516
     517These semantics imply that in order to release of subset of the monitors currently held, users must write (and name) a routine that only acquires the desired subset and simply calls wait. While users can use this method, \CFA offers the \code{wait_release}\footnote{Not sure if an overload of \code{wait} would work...} which will release only the specified monitors. In the center previous examples, the code in the center uses the \code{bar} routine to only release monitor \code{b}. Using the \code{wait_release} helper, this can be rewritten without having the name two routines :
     518\begin{center}
     519\begin{tabular}{ c c c }
     520\begin{lstlisting}
     521        condition e;
     522
     523        //acquire a & b
     524        void foo(monitor & mutex a,
     525                   monitor & mutex b) {
     526                bar(a,b);
     527        }
     528
     529        //acquire b
     530        void bar(monitor & mutex a,
     531                   monitor & nomutex b) {
     532
     533                wait(e); //release b
     534                          //keep a
     535        }
     536
     537        foo(a, b);
     538\end{lstlisting} &\begin{lstlisting}
     539        =>
     540\end{lstlisting} &\begin{lstlisting}
     541        condition e;
     542
     543        //acquire a & b
     544        void foo(monitor & mutex a,
     545                   monitor & mutex b) {
     546                wait_release(e,b); //release b
     547                                         //keep a
     548        }
     549
     550        foo(a, b);
     551\end{lstlisting}
     552\end{tabular}
     553\end{center}
     554
     555Regardless of the context in which the \code{wait} statement is used, \code{signal} must be called holding the same set of monitors. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) that call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor.
    453556
    454557Finally, an additional semantic which can be very usefull is the \code{signal_block} routine. This routine behaves like signal for all of the semantics discussed above, but with the subtelty that mutual exclusion is transferred to the waiting task immediately rather than wating for the end of the critical section.
     
    464567\newpage
    465568\subsection{External scheduling} \label{extsched}
    466 As one might expect, the alternative to Internal scheduling is to use External scheduling instead. This method is somewhat more robust to deadlocks since one of the threads keeps a relatively tight control on scheduling. Indeed, as the following examples will demonstrate, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The following example shows what a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
     569An alternative to internal scheduling is to use external scheduling instead. This method is more constrained and explicit which may help users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The following example shows a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
    467570
    468571\begin{center}
     
    482585
    483586        public:
    484                 void f();
     587                void f() { /*...*/ }
    485588                void g() { _Accept(f); }
    486589        private:
     
    490593\end{center}
    491594
    492 In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} was the last routine to access the monitor. This intails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor.
     595In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} is the last routine to access the monitor. This intails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor.
    493596\\
    494597
     
    673776% #       #     # #     # #     # ####### ####### ####### ####### ###  #####  #     #
    674777\section{Parallelism}
    675 Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being a direct consequence of speed increase, parallelism has become the new source for increased performance~\cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest level approach of parallelism is to use \glspl{kthread} in combination with semantics like \code{fork}, \code{join}, etc. However, since these have significant costs and limitations \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues that all have strengths and weaknesses. While there are many variations of the presented paradigms, most of these variations do not actually change the guarantees or the semantics, they simply move costs in order to achieve better performance for certain workloads.
     778Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being a direct consequence of speed increase, parallelism has become the new source for increased performance~\cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create a high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest-level approach of parallelism is to use \glspl{kthread} in combination with semantics like \code{fork}, \code{join}, etc. However, since these have significant costs and limitations, \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues that all have strengths and weaknesses. While there are many variations of the presented paradigms, most of these variations do not actually change the guarantees or the semantics, they simply move costs in order to achieve better performance for certain workloads.
    676779
    677780\subsection{User-level threads}
    678 A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading problems are hidden, users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
    679 
    680 Examples of languages that support are Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
    681 
    682 \subsection{Fibers : user-level threads without preemption}
    683 In the middle of the flexibility versus complexity spectrum lay \glspl{fiber} which offer \glspl{uthread} without the complexity of preemption by using cooperative scheduling. On a single core machine this means users need not worry about concurrency. On multi-core machines, while concurrency is still a concern, it is only a problem for fibers across cores but not while on the same core. This extra guarantee plus the fact that creating and destroying fibers are implicit synchronizing points means preventing mutable shared ressources still leaves many control flow options. However, multi-core processors can still execute fibers in parallel. This means users either need to worry about mutual exclusion, deadlocks and race conditions, or limit themselves to subset of concurrency primitives, raising the complexity in both cases. In this aspect, fibers can be seen as a more powerfull alternative to \glspl{job}.
     781A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading problems are hidden, users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
     782
     783Examples of languages that support \glspl{uthread} are Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
     784
     785\subsubsection{Fibers : user-level threads without preemption}
     786A popular varient of \glspl{uthread} is what is often reffered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers.
    684787
    685788An example of a language that uses fibers is Go~\cite{Go}
    686789
    687790\subsection{Jobs and thread pools}
    688 The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and the dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur between different jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs will always results in idles cores.
     791The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
    689792
    690793The gold standard of this implementation is Intel's TBB library~\cite{TBB}.
    691794
    692795\subsection{Paradigm performance}
    693 While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead. However, interactions between jobs can easily exacerbate contention. User-level threads may allows fine grain context switching which may result in better resource utilisation but context switches will be more expansive and it is also harder for users to get perfect tunning. As with every example, fibers sit somewhat in the middle of the spectrum. Furthermore, if the units of uninterrupted work are large enough the paradigm choice will be largely amorticised by the actual work done.
     796While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead. However, interactions between jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches will be more expansive and the extra control means users need to tweak more variables to get the desired performance. Furthermore, if the units of uninterrupted work are large enough the paradigm choice is largely amorticised by the actual work done.
    694797
    695798%  #####  #######    #          ####### ######  ######
     
    702805
    703806\section{\CFA 's Thread Building Blocks}
    704 As a system level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency. With this said, it is possible to deconstruct the three paradigms details aboved in order to get simple building blocks. Here is a table showing the core caracteristics of the mentionned paradigms :
    705 \begin{center}
    706 \begin{tabular}[t]{| r | c | c |}
    707 \cline{2-3}
    708 \multicolumn{1}{ c| }{} & Has a stack & Preemptive \\
    709 \hline
    710 \Glspl{pool} & X & X \\
    711 \hline
    712 \Glspl{fiber} & \checkmark & X \\
    713 \hline
    714 \Glspl{uthread} & \checkmark & \checkmark \\
    715 \hline
    716 \end{tabular}
    717 \end{center}
    718 
    719 This table is missing several variations (for example jobs on \glspl{uthread} or \glspl{fiber}), but these variation affect mostly performance and do not effect the guarantees as the presented paradigm do.
    720 
    721 As shown in section \ref{cfaparadigms} these different blocks being available in \CFA it is trivial to reproduce any of these paradigm.
     807As a system-level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency. With this said, deconstructing popular paradigms in order to get simple building blocks yields \glspl{uthread} as the core parallelism block. \Glspl{pool} and other parallelism paradigms can then be built on top of the underlying threading model.
    722808
    723809% ####### #     # ######  #######    #    ######   #####
     
    730816
    731817\subsection{Thread Interface}
    732 The basic building blocks of \CFA are \glspl{cfathread}. By default these are implemented as \glspl{uthread} and as such offer a flexible and lightweight threading interface (lightweight comparatievely to \glspl{kthread}). A thread can be declared using a struct declaration with prefix \code{thread} as follows :
     818The basic building blocks of \CFA are \glspl{cfathread}. By default these are implemented as \glspl{uthread}, and as such, offer a flexible and lightweight threading interface (lightweight compared to \glspl{kthread}). A thread can be declared using a struct declaration with prefix \code{thread} as follows :
    733819
    734820\begin{lstlisting}
     
    736822\end{lstlisting}
    737823
    738 Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use some function pointer representation as the interface of threads (for example : \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is definitely a special routine in \CFA, the existing syntax for declaring routines with unordinary name can be extended, i.e. operator overloading. As such the \code{main} routine of a thread can be defined as :
     824Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use a function-pointer representation as the interface of threads (for example : \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is already a special routine in \CFA (where the program begins), the existing syntax for declaring routines names with special semantics can be extended, i.e. operator overloading. As such the \code{main} routine of a thread can be defined as :
    739825\begin{lstlisting}
    740826        thread struct foo {};
    741827
    742         void ?main(thread foo* this) {
    743                 /*... Some useful code ...*/
    744         }
    745 \end{lstlisting}
    746 
    747 With these semantics it is trivial to write a thread type that takes a function pointer as parameter and executes it on its stack asynchronously :
     828        void ?main(foo* this) {
     829                sout | "Hello World!" | endl;
     830        }
     831\end{lstlisting}
     832
     833In this example, threads of type \code{foo} will start there execution in the \code{void ?main(foo*)} routine which in this case prints \code{"Hello World!"}. While this proposoal encourages this approach which is enforces strongly type programming. Users may prefer to use the routine based thread semantics for the sake of simplicity. With these semantics it is trivial to write a thread type that takes a function pointer as parameter and executes it on its stack asynchronously :
    748834\begin{lstlisting}
    749835        typedef void (*voidFunc)(void);
     
    754840
    755841        //ctor
    756         void ?{}(thread FuncRunner* this, voidFunc inFunc) {
     842        void ?{}(FuncRunner* this, voidFunc inFunc) {
    757843                func = inFunc;
    758844        }
    759845
    760846        //main
    761         void ?main(thread FuncRunner* this) {
     847        void ?main(FuncRunner* this) {
    762848                this->func();
    763849        }
    764850\end{lstlisting}
    765851
    766 % In this example \code{func} is a function pointer stored in \acrfull{tls}, which is \CFA is both easy to use and completly typesafe.
    767 
    768 Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is not needed. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} once the constructor has completed and \code{join} before the destructor runs.
    769 \begin{lstlisting}
    770 thread struct FuncRunner; //FuncRunner declared above
    771 
    772 void world() {
     852Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is unnecessary. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} once the constructor has completed and \code{join} before the destructor runs.
     853\begin{lstlisting}
     854thread struct World; //FuncRunner declared above
     855
     856void ?main(thread World* this) {
    773857        sout | "World!" | endl;
    774858}
    775859
    776860void main() {
    777         FuncRunner run = {world};
     861        World w;
    778862        //Thread run forks here
    779863
     
    784868}
    785869\end{lstlisting}
    786 This semantic has several advantages over explicit semantics : typesafety is guaranteed, a thread is always started and stopped exaclty once and users cannot make any progamming errors. Furthermore it naturally follows the memory allocation semantics, which means users do not need to learn multiple semantics.
    787 
    788 These semantics also naturally scale to multiple threads meaning basic synchronisation is very simple :
     870This semantic has several advantages over explicit semantics : typesafety is guaranteed, a thread is always started and stopped exaclty once and users cannot make any progamming errors. However, one of the apparent drawbacks of this system is that threads now always form a lattice, that is they are always destroyed in opposite order of construction. While this seems like a significant limitation, existing \CFA semantics can solve this problem. Indeed, by using dynamic allocation to create threads will naturally let threads outlive the scope in which the thread was created much like dynamically allocating memory will let objects outlive the scope in which thy were created :
     871
    789872\begin{lstlisting}
    790873        thread struct MyThread {
     
    793876
    794877        //ctor
    795         void ?{}(thread MyThread* this) {}
     878        void ?{}(MyThread* this,
     879                     bool is_special = false) {
     880                //...
     881        }
    796882
    797883        //main
    798         void ?main(thread MyThread* this) {
     884        void ?main(MyThread* this) {
     885                //...
     886        }
     887
     888        void foo() {
     889                MyThread* special_thread;
     890                {
     891                        MyThread thrds = {false};
     892                        //Start a thread at the beginning of the scope
     893
     894                        DoStuff();
     895
     896                        //create a other thread that will outlive the thread in this scope
     897                        special_thread = new MyThread{true};
     898
     899                        //Wait for the thread to finish
     900                }
     901                DoMoreStuff();
     902
     903                //Now wait for the special
     904        }
     905\end{lstlisting}
     906
     907Another advantage of this semantic is that it naturally scale to multiple threads meaning basic synchronisation is very simple :
     908
     909\begin{lstlisting}
     910        thread struct MyThread {
     911                //...
     912        };
     913
     914        //ctor
     915        void ?{}(MyThread* this) {}
     916
     917        //main
     918        void ?main(MyThread* this) {
    799919                //...
    800920        }
     
    808928                //Wait for the 10 threads to finish
    809929        }
    810 
    811         void bar() {
    812                 MyThread* thrds = new MyThread[10];
    813                 //Start 10 threads at the beginning of the scope
    814 
    815                 DoStuff();
    816 
    817                 //Wait for the 10 threads to finish
    818                 delete MyThread;
     930\end{lstlisting}
     931
     932\subsection{Coroutines : A stepping stone}\label{coroutine}
     933While the main focus of this proposal is concurrency and paralellism, it is important to adress coroutines which are actually a significant underlying aspect of the concurrency system. Indeed, while having nothing todo with parallelism and arguably very little to do with concurrency, coroutines need to deal with context-switchs and and other context management operations. Therefore, this proposal includes coroutines both as an intermediate step for the implementation of threads and a first class feature of \CFA.
     934
     935The core API of coroutines revolve around two features : independent stacks and suspedn/resume. Much like threads the syntax for declaring a coroutine is declaring a type and a main routine for it to start :
     936\begin{lstlisting}
     937        coroutine struct MyCoroutine {
     938                //...
     939        };
     940
     941        //ctor
     942        void ?{}(MyCoroutine* this) {
     943
     944        }
     945
     946        //main
     947        void ?main(MyCoroutine* this) {
     948                sout | "Hello World!" | endl;
     949        }
     950\end{lstlisting}
     951
     952One a coroutine is created, users can context switch to it using \code{suspend} and come back using \code{resume}. Here is an example of a solution to the fibonnaci problem using coroutines :
     953\begin{lstlisting}
     954        coroutine struct Fibonacci {
     955                int fn; // used for communication
     956        };
     957
     958        void ?main(Fibonacci* this) {
     959                int fn1, fn2;           // retained between resumes
     960                this->fn = 0;
     961                fn1 = this->fn;
     962                suspend(this);          // return to last resume
     963
     964                this->fn = 1;
     965                fn2 = fn1;
     966                fn1 = this->fn;
     967                suspend(this);          // return to last resume
     968
     969                for ( ;; ) {
     970                        this->fn = fn1 + fn2;
     971                        fn2 = fn1;
     972                        fn1 = this->fn;
     973                        suspend(this);  // return to last resume
     974                }
     975        }
     976
     977        int next(Fibonacci& this) {
     978                resume(&this); // transfer to last suspend
     979                return this.fn;
     980        }
     981
     982        void main() {
     983                Fibonacci f1, f2;
     984                for ( int i = 1; i <= 10; i += 1 ) {
     985                        sout | next(f1) | '§\verb+ +§' | next(f2) | endl;
     986                }
    819987        }
    820988\end{lstlisting}
    821989
    822990\newpage
    823 \large{\textbf{WORK IN PROGRESS}}
     991\bf{WORK IN PROGRESS}
    824992\subsection{The \CFA Kernel : Processors, Clusters and Threads}\label{kernel}
    825993
  • doc/proposals/concurrency/glossary.tex

    r5802a4f r66f8528  
    1414
    1515\longnewglossaryentry{group-acquire}
    16 {name={grouped acquiring}}
     16{name={bulked acquiring}}
    1717{
    1818Implicitly acquiring several monitors when entering a monitor.
  • doc/proposals/concurrency/style.tex

    r5802a4f r66f8528  
    22
    33\lstset{
    4 morekeywords=[2]{nomutex,mutex,thread,wait,wait_release,signal,signal_block,accept,monitor},
     4morekeywords=[2]{nomutex,mutex,thread,wait,wait_release,signal,signal_block,accept,monitor,suspend,resume,coroutine},
    55keywordstyle=[2]\color{blue},                           % second set of keywords for concurency
    66basicstyle=\linespread{0.9}\tt\small,           % reduce line spacing and use typewriter font
  • doc/proposals/concurrency/version

    r5802a4f r66f8528  
    1 0.5.150
     10.7.48
  • doc/working/resolver_design.md

    r5802a4f r66f8528  
    13821382hypothesis needs to be empirically validated.
    13831383
     1384Another approach would be to abandon expression-tree ordering for
     1385subexpression matching, and order by "most constrained symbol"; symbols would 
     1386be more constrained if there were fewer matching declarations, fewer
     1387subexpressions yet to resolve, or possibly fewer possible types the expression
     1388could resolve to. Ordering the expressions in a priority-queue by this metric
     1389would not necessarily produce a top-down or a bottom-up order, but would add
     1390opportunities for pruning based on memoized upper and lower bounds.
     1391
    13841392Both Baker and Cormack explicitly generate all possible interpretations of a
    13851393given expression; thinking of the set of interpretations of an expression as a
  • src/CodeGen/CodeGenerator.cc

    r5802a4f r66f8528  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 13:35:30 2016
    13 // Update Count     : 352
     12// Last Modified On : Tue Dec 13 14:51:27 2016
     13// Update Count     : 362
    1414//
    1515
     
    5757                if ( decl->get_extension() ) {
    5858                        output << "__extension__ ";
     59                } // if
     60        } // extension
     61
     62        void CodeGenerator::asmName( DeclarationWithType * decl ) {
     63                if ( ConstantExpr * asmName = decl->get_asmName() ) {
     64                        output << " asm ( " << asmName->get_constant()->get_value() << " )";
    5965                } // if
    6066        } // extension
     
    141147                } // if
    142148
     149                asmName( functionDecl );
     150
    143151                // acceptAll( functionDecl->get_oldDecls(), *this );
    144152                if ( functionDecl->get_statements() ) {
     
    153161                handleStorageClass( objectDecl );
    154162                output << genType( objectDecl->get_type(), mangleName( objectDecl ) );
     163
     164                asmName( objectDecl );
    155165
    156166                if ( objectDecl->get_init() ) {
  • src/CodeGen/CodeGenerator.h

    r5802a4f r66f8528  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 13:37:07 2016
    13 // Update Count     : 38
     12// Last Modified On : Tue Dec 13 13:51:53 2016
     13// Update Count     : 39
    1414//
    1515
     
    108108                };
    109109
     110                void asmName( DeclarationWithType *decl );
     111
    110112                void extension( Expression *expr );
    111113                void extension( Declaration *decl );
  • src/CodeGen/GenType.cc

    r5802a4f r66f8528  
    204204        void GenType::visit( ZeroType *zeroType ) {
    205205                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
    206                 typeString = "int " + typeString;
     206                typeString = "long int " + typeString;
    207207                handleQualifiers( zeroType );
    208208        }
     
    210210        void GenType::visit( OneType *oneType ) {
    211211                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
    212                 typeString = "int " + typeString;
     212                typeString = "long int " + typeString;
    213213                handleQualifiers( oneType );
    214214        }
  • src/CodeGen/OperatorTable.cc

    r5802a4f r66f8528  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Thu Apr 14 16:48:27 2016
    13 // Update Count     : 9
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Dec 13 14:33:05 2016
     13// Update Count     : 10
    1414//
    1515
     
    2121                const OperatorInfo tableValues[] = {
    2222                        {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
    23                         {       "?{}",          "=",            "_constructor",                                 OT_CTOR                         },
     23                        {       "?{}",          "=",    "_constructor",                                 OT_CTOR                         },
    2424                        {       "^?{}",         "",             "_destructor",                                  OT_DTOR                         },
    2525                        {       "?()",          "",             "_operator_call",                               OT_CALL                         },
  • src/Common/Assert.cc

    r5802a4f r66f8528  
    1 // 
     1//
    22// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
    33//
    44// The contents of this file are covered under the licence agreement in the
    55// file "LICENCE" distributed with Cforall.
    6 // 
    7 // Assert.cc -- 
    8 // 
     6//
     7// Assert.cc --
     8//
    99// Author           : Peter A. Buhr
    1010// Created On       : Thu Aug 18 13:26:59 2016
     
    1212// Last Modified On : Fri Aug 19 17:07:08 2016
    1313// Update Count     : 10
    14 // 
     14//
    1515
    1616#include <assert.h>
     
    3535        va_start( args, fmt );
    3636        vfprintf( stderr, fmt, args );
     37        va_end( args );
     38        fprintf( stderr, "\n" );
    3739        abort();
    3840}
     
    4345// compile-command: "make install" //
    4446// End:  //
    45 
  • src/Common/utility.h

    r5802a4f r66f8528  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep 23 11:46:47 2016
    13 // Update Count     : 28
     12// Last Modified On : Wed Dec 14 21:25:25 2016
     13// Update Count     : 31
    1414//
    1515
     
    3636}
    3737
    38 template<typename T, typename U>
     38template< typename T, typename U >
    3939struct maybeBuild_t {
    4040        static T * doit( const U *orig ) {
  • src/InitTweak/FixInit.cc

    r5802a4f r66f8528  
    346346
    347347                        if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
    348                                 if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
     348                                if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
    349349                                        // optimization: don't need to copy construct in order to call intrinsic functions
    350350                                        return appExpr;
  • src/InitTweak/InitTweak.cc

    r5802a4f r66f8528  
    304304
    305305        namespace {
     306                DeclarationWithType * getCalledFunction( Expression * expr );
     307
     308                template<typename CallExpr>
     309                DeclarationWithType * handleDerefCalledFunction( CallExpr * expr ) {
     310                        // (*f)(x) => should get "f"
     311                        std::string name = getFunctionName( expr );
     312                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
     313                        assertf( ! expr->get_args().empty(), "Can't get called function from dereference with no arguments" );
     314                        return getCalledFunction( expr->get_args().front() );
     315                }
     316
    306317                DeclarationWithType * getCalledFunction( Expression * expr ) {
    307318                        assert( expr );
     
    312323                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
    313324                                return getCalledFunction( castExpr->get_arg() );
     325                        } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
     326                                return handleDerefCalledFunction( untypedExpr );
     327                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
     328                                return handleDerefCalledFunction( appExpr );
    314329                        }
    315330                        return nullptr;
     
    377392
    378393        namespace {
     394                std::string funcName( Expression * func );
     395
     396                template<typename CallExpr>
     397                std::string handleDerefName( CallExpr * expr ) {
     398                        // (*f)(x) => should get name "f"
     399                        std::string name = getFunctionName( expr );
     400                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
     401                        assertf( ! expr->get_args().empty(), "Can't get function name from dereference with no arguments" );
     402                        return funcName( expr->get_args().front() );
     403                }
     404
    379405                std::string funcName( Expression * func ) {
    380406                        if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
     
    388414                        } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
    389415                                return funcName( memberExpr->get_member() );
     416                        } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( func ) ) {
     417                                return handleDerefName( untypedExpr );
     418                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( func ) ) {
     419                                return handleDerefName( appExpr );
    390420                        } else {
    391421                                assertf( false, "Unexpected expression type being called as a function in call expression" );
     
    395425
    396426        std::string getFunctionName( Expression * expr ) {
     427                // there's some unforunate overlap here with getCalledFunction. Ideally this would be able to use getCalledFunction and
     428                // return the name of the DeclarationWithType, but this needs to work for NameExpr and UntypedMemberExpr, where getCalledFunction
     429                // can't possibly do anything reasonable.
    397430                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
    398431                        return funcName( appExpr->get_function() );
  • src/Makefile.am

    r5802a4f r66f8528  
    4141driver_cfa_cpp_SOURCES = ${SRC}
    4242driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    43 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT
     43driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2
    4444driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
    4545
  • src/Makefile.in

    r5802a4f r66f8528  
    6969PRE_UNINSTALL = :
    7070POST_UNINSTALL = :
     71build_triplet = @build@
     72host_triplet = @host@
    7173DIST_COMMON = $(srcdir)/CodeGen/module.mk $(srcdir)/Common/module.mk \
    7274        $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk \
     
    259261BACKEND_CC = @BACKEND_CC@
    260262CC = @CC@
     263CCAS = @CCAS@
     264CCASDEPMODE = @CCASDEPMODE@
     265CCASFLAGS = @CCASFLAGS@
    261266CCDEPMODE = @CCDEPMODE@
    262267CFA_BACKEND_CC = @CFA_BACKEND_CC@
     
    293298LIBS = @LIBS@
    294299LTLIBOBJS = @LTLIBOBJS@
     300MACHINE_TYPE = @MACHINE_TYPE@
    295301MAINT = @MAINT@
    296302MAKEINFO = @MAKEINFO@
     
    324330am__untar = @am__untar@
    325331bindir = @bindir@
     332build = @build@
    326333build_alias = @build_alias@
     334build_cpu = @build_cpu@
     335build_os = @build_os@
     336build_vendor = @build_vendor@
    327337builddir = @builddir@
    328338datadir = @datadir@
     
    331341dvidir = @dvidir@
    332342exec_prefix = @exec_prefix@
     343host = @host@
    333344host_alias = @host_alias@
     345host_cpu = @host_cpu@
     346host_os = @host_os@
     347host_vendor = @host_vendor@
    334348htmldir = @htmldir@
    335349includedir = @includedir@
     
    418432driver_cfa_cpp_SOURCES = ${SRC}
    419433driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    420 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT
     434driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2
    421435driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
    422436all: $(BUILT_SOURCES)
  • src/Parser/DeclarationNode.cc

    r5802a4f r66f8528  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Oct  3 18:03:08 2016
    13 // Update Count     : 651
     12// Last Modified On : Tue Dec 13 14:43:38 2016
     13// Update Count     : 660
    1414//
    1515
     
    4848                type( nullptr ),
    4949                storageClass( NoStorageClass ),
     50                bitfieldWidth( nullptr ),
    5051                isInline( false ),
    5152                isNoreturn( false ),
    52                 bitfieldWidth( nullptr ),
    53                 initializer( nullptr ),
    5453                hasEllipsis( false ),
    5554                linkage( ::linkage ),
     55                asmName( nullptr ),
     56                initializer( nullptr ),
    5657                extension( false ) {
    5758
     
    7576        delete type;
    7677        delete bitfieldWidth;
     78        // asmName, no delete, passed to next stage
    7779        delete initializer;
    7880}
     
    9092        newnode->set_next( maybeClone( get_next() ) );
    9193        newnode->linkage = linkage;
     94        newnode->asmName = maybeClone( asmName );
    9295
    9396//      newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
     
    283286        DeclarationNode * newnode = new DeclarationNode;
    284287        newnode->type = nullptr;
    285         assert( ! newnode->name ); 
     288        assert( ! newnode->name );
    286289//      newnode->variable.name = name;
    287290        newnode->name = name;
     
    372375        newnode->type = new TypeData( TypeData::Builtin );
    373376        newnode->builtin = bt;
     377        newnode->type->builtintype = newnode->builtin;
    374378        return newnode;
    375379} // DeclarationNode::newBuiltinType
     
    640644}
    641645
     646DeclarationNode * DeclarationNode::addAsmName( ConstantExpr * newname ) {
     647        assert( ! asmName );
     648        asmName = newname;
     649        return this;
     650}
     651
    642652DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) {
    643653        bitfieldWidth = size;
     
    946956
    947957        if ( type ) {
    948                 return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
     958                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, asmName, maybeBuild< Initializer >(initializer) )->set_extension( extension );
    949959        } // if
    950960
    951961        if ( ! isInline && ! isNoreturn ) {
    952962                assertf( name, "ObjectDecl are assumed to have names\n" );
    953                 return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
     963                return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    954964        } // if
    955965
  • src/Parser/ExpressionNode.cc

    r5802a4f r66f8528  
    4646// type.
    4747
    48 static Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
     48Type::Qualifiers emptyQualifiers;                               // no qualifiers on constants
    4949
    5050static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
     
    172172} // build_constantStr
    173173
     174Expression *build_constantZeroOne( const std::string & str ) {
     175        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type*)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
     176        delete &str;                                                                            // created by lex
     177        return ret;
     178} // build_constantChar
     179
    174180Expression * build_field_name_FLOATINGconstant( const std::string & str ) {
    175181        // str is of the form A.B -> separate at the . and return member expression
  • src/Parser/ParseNode.h

    r5802a4f r66f8528  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Oct  3 18:03:08 2016
    13 // Update Count     : 636
     12// Last Modified On : Tue Dec 13 15:37:33 2016
     13// Update Count     : 643
    1414//
    1515
     
    154154Expression * build_constantFloat( const std::string &str );
    155155Expression * build_constantChar( const std::string &str );
     156Expression * build_constantZeroOne( const std::string &str );
    156157ConstantExpr * build_constantStr( const std::string &str );
    157158Expression * build_field_name_FLOATINGconstant( const std::string & str );
     
    204205        enum Aggregate { Struct, Union, Trait, NoAggregate };
    205206        enum TypeClass { Otype, Dtype, Ftype, NoTypeClass };
    206         enum BuiltinType { Valist };
     207        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
    207208
    208209        static const char * storageName[];
     
    256257        DeclarationNode * addAssertions( DeclarationNode * );
    257258        DeclarationNode * addName( std::string * );
     259        DeclarationNode * addAsmName( ConstantExpr * );
    258260        DeclarationNode * addBitfield( ExpressionNode * size );
    259261        DeclarationNode * addVarArgs();
     
    308310        TypeData * type;
    309311        StorageClass storageClass;
     312        ExpressionNode * bitfieldWidth;
    310313        bool isInline, isNoreturn;
    311         std::list< std::string > attributes;
    312         ExpressionNode * bitfieldWidth;
    313314        std::unique_ptr<ExpressionNode> enumeratorValue;
    314         InitializerNode * initializer;
    315315        bool hasEllipsis;
    316316        LinkageSpec::Spec linkage;
     317        ConstantExpr *asmName;
     318        std::list< std::string > attributes;
     319        InitializerNode * initializer;
    317320        bool extension = false;
    318321        std::string error;
  • src/Parser/TypeData.cc

    r5802a4f r66f8528  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Sep 24 11:14:26 2016
    13 // Update Count     : 415
     12// Last Modified On : Tue Dec 13 13:40:33 2016
     13// Update Count     : 420
    1414//
    1515
     
    215215                break;
    216216          case Builtin:
    217                 assert( false );
    218                 // newtype->builtin = builtin;
     217                assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One );
     218                newtype->builtintype = builtintype;
    219219                break;
    220220        } // switch
     
    444444                return buildTypeof( td );
    445445          case TypeData::Builtin:
    446                 return new VarArgsType( buildQualifiers( td ) );
     446                if(td->builtintype == DeclarationNode::Zero) {
     447                        return new ZeroType( emptyQualifiers );
     448                }
     449                else if(td->builtintype == DeclarationNode::One) {
     450                        return new OneType( emptyQualifiers );
     451                }
     452                else {
     453                        return new VarArgsType( buildQualifiers( td ) );
     454                }
    447455          case TypeData::Symbolic:
    448456          case TypeData::Enum:
     
    574582                const_cast<TypeData *>(td)->basictype = DeclarationNode::Int;
    575583                goto Integral;
     584          default:
     585                assert(false);
     586                return nullptr;
    576587        } // switch
    577588
     
    710721} // buildTypeof
    711722
    712 Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
     723Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init ) {
    713724        if ( td->kind == TypeData::Function ) {
    714725                FunctionDecl * decl;
     
    732743                } // for
    733744                buildList( td->function.oldDeclList, decl->get_oldDecls() );
    734                 return decl;
     745                return decl->set_asmName( asmName );
    735746        } else if ( td->kind == TypeData::Aggregate ) {
    736747                return buildAggregate( td );
     
    740751                return buildSymbolic( td, name, sc );
    741752        } else {
    742                 return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn );
     753                return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn ))->set_asmName( asmName );
    743754        } // if
    744755        return nullptr;
     
    758769                        break;
    759770                  default:
    760                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) );
     771                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall, nullptr ) ) );
    761772                } // switch
    762773        } else {
  • src/Parser/TypeData.h

    r5802a4f r66f8528  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypeData.h -- 
     7// TypeData.h --
    88//
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Oct  3 12:34:08 2016
    13 // Update Count     : 142
     12// Last Modified On : Tue Dec 13 13:39:39 2016
     13// Update Count     : 143
    1414//
    1515
     
    7474        DeclarationNode::Signedness signedness = DeclarationNode::NoSignedness;
    7575        DeclarationNode::Length length = DeclarationNode::NoLength;
     76        DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
    7677        typedef std::bitset< DeclarationNode::NoQualifier > Qualifiers;
    7778        Qualifiers qualifiers;
     
    110111TupleType * buildTuple( const TypeData * );
    111112TypeofType * buildTypeof( const TypeData * );
    112 Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr );
     113Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr );
    113114FunctionType * buildFunction( const TypeData * );
    114115
  • src/Parser/lex.cc

    r5802a4f r66f8528  
    382382        (yy_c_buf_p) = yy_cp;
    383383
    384 #define YY_NUM_RULES 183
    385 #define YY_END_OF_BUFFER 184
     384#define YY_NUM_RULES 185
     385#define YY_END_OF_BUFFER 186
    386386/* This struct is not used in this scanner,
    387387   but its presence is necessary. */
     
    391391        flex_int32_t yy_nxt;
    392392        };
    393 static yyconst flex_int16_t yy_accept[895] =
     393static yyconst flex_int16_t yy_accept[905] =
    394394    {   0,
    395         0,    0,    0,    0,    0,    0,  118,  118,  121,  121,
    396       184,  182,    7,    9,    8,  141,  120,  103,  146,  149,
    397       117,  128,  129,  144,  142,  132,  143,  135,  145,  108,
    398       109,  110,  133,  134,  151,  153,  152,  154,  182,  103,
    399       126,  182,  127,  147,  103,  105,  103,  103,  103,  103,
    400       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    401       103,  103,  130,  150,  131,  148,    7,  182,    4,    4,
    402       183,  106,  183,  107,  118,  119,  125,  121,  122,    7,
    403         9,    0,    8,  158,  177,  103,    0,  170,  140,  163,
    404       171,  168,  155,  166,  156,  167,  165,    0,  114,    3,
    405 
    406         0,  169,  113,  111,    0,    0,  111,  111,    0,    0,
    407       111,  110,  110,  110,    0,  110,  138,  139,  137,  159,
    408       161,  157,  162,  160,    0,    0,    0,    0,    0,    0,
    409         0,    0,    0,    0,    0,    0,    0,    0,    0,  104,
    410       176,    0,  120,  117,  103,    0,    0,  173,    0,  103,
    411       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    412       103,  103,  103,  103,  103,  103,   38,  103,  103,  103,
    413       103,  103,  103,  103,  103,  103,  103,   57,  103,  103,
    414       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    415       103,  103,  103,  103,  172,  164,    7,    0,    0,    0,
    416 
    417         2,    0,    5,  106,    0,    0,    0,  118,    0,  124,
    418       123,  123,    0,    0,    0,  121,    0,    0,    0,    0,
     395        0,    0,    0,    0,    0,    0,  120,  120,  123,  123,
     396      186,  184,    7,    9,    8,  143,  122,  105,  148,  151,
     397      119,  130,  131,  146,  144,  134,  145,  137,  147,  110,
     398      111,  112,  135,  136,  153,  155,  154,  156,  184,  105,
     399      128,  184,  129,  149,  105,  107,  105,  105,  105,  105,
     400      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     401      105,  105,  105,  132,  152,  133,  150,    7,  184,    4,
     402        4,  185,  108,  185,  109,  120,  121,  127,  123,  124,
     403        7,    9,    0,    8,  160,  179,  105,    0,  172,  142,
     404      165,  173,  170,  157,  168,  158,  169,  167,    0,  116,
     405
     406        3,    0,  171,  115,  113,    0,    0,  113,  113,    0,
     407        0,  113,  112,  112,  112,    0,  112,  140,  141,  139,
     408      161,  163,  159,  164,  162,    0,    0,    0,    0,    0,
    419409        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    420         0,  136,  114,  115,    0,  115,  115,    0,    0,    6,
    421       115,  111,    0,    0,    0,  115,    0,  111,  111,  111,
    422       111,    0,  112,    0,    0,  110,  110,  110,  110,    0,
    423       174,  175,    0,  180,  178,    0,    0,    0,  104,    0,
    424         0,    0,    0,    0,    0,    0,    0,  103,   17,  103,
    425       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    426       103,  103,  103,  103,  103,  103,  103,   14,  103,  103,
    427 
    428       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    429       103,  103,  103,  103,  103,  103,   51,  103,  103,  103,
    430        64,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    431       103,  103,  103,  103,  103,   90,  103,  103,  103,  103,
    432       103,  103,  103,    0,    0,    0,    0,    0,    0,    0,
    433         0,  123,    0,    0,    0,    0,    0,  123,    0,    0,
    434       181,    0,    0,    0,    0,    0,    0,    0,  115,    0,
    435       115,    0,  115,    0,  115,    0,    0,  115,    0,  111,
    436       111,    0,    0,  112,  112,    0,  112,    0,  112,  110,
    437       110,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    438 
    439         0,  179,  103,  103,  103,  103,  103,  103,  103,  103,
    440       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    441       103,  103,  103,  103,  103,   21,  103,   24,  103,   27,
    442       103,  103,  103,  103,  103,  103,  103,   41,  103,   43,
    443       103,  103,  103,  103,  103,  103,  103,   56,  103,   67,
    444       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    445       103,  103,  103,  103,  103,  103,   98,  103,  103,    0,
     410      106,  178,    0,  122,  119,  105,    0,    0,  175,    0,
     411      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     412      105,  105,  105,  105,  105,  105,  105,   38,  105,  105,
     413      105,  105,  105,  105,  105,  105,  105,  105,   57,  105,
     414      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     415      105,  105,  105,  105,  105,  105,  105,  174,  166,    7,
     416
     417        0,    0,    0,    2,    0,    5,  108,    0,    0,    0,
     418      120,    0,  126,  125,  125,    0,    0,    0,  123,    0,
    446419        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    447         0,    0,    0,  123,    0,    0,    0,    0,    0,  115,
    448         0,    0,    0,    0,    0,    0,    0,  112,  112,    0,
    449 
    450       116,    0,  112,  112,    0,    0,    0,    0,    0,    0,
    451         0,    0,    0,    0,    0,    0,    0,  103,  103,   22,
    452       103,  103,  103,  103,  103,  103,  103,   15,  103,  103,
    453       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    454       103,  103,   23,   25,  103,   32,  103,  103,  103,  103,
    455        40,  103,  103,  103,  103,   49,  103,  103,   54,  103,
    456       103,   71,  103,  103,  103,   77,  103,  103,  103,  103,
    457       103,   87,   89,  103,  103,   95,  103,  103,  102,    0,
     420        0,    0,    0,    0,  138,  116,  117,    0,  117,  117,
     421        0,    0,    6,  117,  113,    0,    0,    0,  117,    0,
     422      113,  113,  113,  113,    0,  114,    0,    0,  112,  112,
     423      112,  112,    0,  176,  177,    0,  182,  180,    0,    0,
     424        0,  106,    0,    0,    0,    0,    0,    0,    0,    0,
     425      105,   17,  105,  105,  105,  105,  105,  105,  105,  105,
     426      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     427
     428       14,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     429      105,  105,  105,  105,  105,  105,  105,  105,  105,   51,
     430      105,  105,  105,   64,  105,  105,  105,  105,  105,  105,
     431      105,  105,  105,  105,  105,  105,  105,  105,  105,   91,
     432      105,  105,  105,  105,  105,  105,  105,  105,    0,    0,
     433        0,    0,    0,    0,    0,    0,  125,    0,    0,    0,
     434        0,    0,  125,    0,    0,  183,    0,    0,    0,    0,
     435        0,    0,    0,  117,    0,  117,    0,  117,    0,  117,
     436        0,    0,  117,    0,  113,  113,    0,    0,  114,  114,
     437        0,  114,    0,  114,  112,  112,    0,    0,    0,    0,
     438
     439        0,    0,    0,    0,    0,    0,  181,  105,  105,  105,
     440      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     441      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     442       21,  105,   24,  105,   27,  105,  105,  105,  105,  105,
     443      105,  105,   41,  105,   43,  105,  105,  105,  105,  105,
     444      105,  105,   56,  105,   67,  105,  105,  105,  105,  105,
     445      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     446      105,  105,   99,  105,  105,  105,    0,    0,    0,    0,
    458447        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    459         0,    0,    0,    0,    0,    0,    0,    0,  116,    0,
    460 
    461         0,  112,  116,  116,  116,  116,    0,  112,    0,    0,
    462         0,    0,    0,    0,    0,    0,    0,    0,  103,    0,
    463       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
    464       103,  103,  103,  103,  103,  103,   59,  103,  103,  103,
    465       103,  103,  103,  103,  103,   28,  103,  103,  103,   39,
    466        42,   45,  103,  103,   52,  103,   61,   68,  103,  103,
    467        76,   78,   81,   82,   84,   85,  103,  103,   92,  103,
    468       103,    0,    1,    0,    0,    0,    0,    0,    0,  106,
    469         0,    0,    0,  123,    0,    0,    0,    0,  116,    0,
    470       116,  116,    0,    0,    0,    0,    0,    0,    0,    0,
    471 
    472         0,  103,  103,   18,  103,  103,  103,  103,  103,  103,
    473       103,   16,  103,  103,  103,   33,  103,  103,  103,  103,
    474       103,  103,  103,  103,  103,  103,  103,  103,   36,   37,
    475       103,   48,   53,  103,  103,  103,   91,  103,  103,    0,
     448      125,    0,    0,    0,    0,    0,  117,    0,    0,    0,
     449
     450        0,    0,    0,    0,  114,  114,    0,  118,    0,  114,
     451      114,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     452        0,    0,    0,    0,  105,  105,   22,  105,  105,  105,
     453      105,  105,  105,  105,   15,  105,  105,  105,  105,  105,
     454      105,  105,  105,  105,  105,  105,  105,  105,  105,   23,
     455       25,  105,   32,  105,  105,  105,  105,   40,  105,  105,
     456      105,  105,   49,  105,  105,   54,  105,  105,   71,   72,
     457      105,  105,  105,   78,  105,  105,  105,  105,  105,   88,
     458       90,  105,  105,   96,  105,  105,  103,  105,    0,    0,
    476459        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    477         0,    0,   10,   11,   29,   55,  103,  103,  103,  103,
    478       103,  103,  103,  103,  103,  103,  103,   60,   62,   65,
    479       103,  103,   79,   93,  103,  103,   35,  103,   47,   72,
    480        73,  103,   96,   99,    0,    0,    0,    0,    0,    0,
    481         0,    0,    0,    0,    0,    0,  103,   69,  103,  103,
    482 
    483        12,  103,  103,   30,   34,  103,  103,  103,   66,  103,
    484       103,  103,  103,  103,  103,  103,    0,    0,    0,    0,
     460
     461        0,    0,    0,    0,    0,    0,    0,  118,    0,    0,
     462      114,  118,  118,  118,  118,    0,  114,    0,    0,    0,
     463        0,    0,    0,    0,    0,    0,    0,  105,    0,  105,
     464      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
     465      105,  105,  105,  105,  105,   59,  105,  105,  105,  105,
     466      105,  105,  105,  105,   28,  105,  105,  105,   39,   42,
     467       45,  105,  105,   52,  105,   61,   68,  105,  105,   77,
     468       79,   82,   83,   85,   86,  105,  105,   93,  105,  105,
     469      104,    0,    1,    0,    0,    0,    0,    0,    0,  108,
     470        0,    0,    0,  125,    0,    0,    0,    0,  118,    0,
     471
     472      118,  118,    0,    0,    0,    0,    0,    0,    0,    0,
     473        0,  105,  105,   18,  105,  105,  105,  105,  105,  105,
     474      105,   16,  105,  105,  105,   33,  105,  105,  105,  105,
     475      105,  105,  105,  105,  105,  105,  105,  105,   36,   37,
     476      105,   48,   53,  105,  105,  105,   92,  105,  105,    0,
     477        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     478        0,    0,   10,   11,   29,   55,  105,  105,  105,  105,
     479      105,  105,  105,  105,  105,  105,  105,   60,   62,   65,
     480      105,  105,   80,   94,  105,  105,   35,  105,   47,   73,
     481       74,  105,   97,  100,    0,    0,    0,    0,    0,    0,
     482
     483        0,    0,    0,    0,    0,    0,  105,   69,  105,  105,
     484       12,  105,  105,   30,   34,  105,  105,  105,   66,  105,
     485      105,  105,  105,  105,  105,  105,    0,    0,    0,    0,
    485486        0,    0,    0,    0,    0,    0,    0,    0,    0,   58,
    486       103,  103,  103,  103,  103,  103,  103,   50,   63,   74,
    487        80,   94,  100,  103,  103,  103,    0,    0,    0,    0,
    488         0,    0,    0,    0,  103,  103,   13,   19,  103,  103,
    489        31,  103,  103,  103,   26,   46,   88,    0,    0,  103,
    490       103,  103,  103,  103,  103,   75,  101,  103,   86,   20,
    491       103,  103,   44,   83,  103,  103,  103,  103,  103,  103,
    492       103,   97,   70,    0
    493 
     487      105,  105,  105,  105,  105,  105,  105,   50,   63,   75,
     488       81,   95,  101,  105,  105,  105,    0,    0,    0,    0,
     489        0,    0,    0,    0,  105,  105,   13,   19,  105,  105,
     490       31,  105,  105,  105,   26,   46,   89,    0,    0,  105,
     491      105,  105,  105,  105,  105,   76,  102,  105,   87,   20,
     492      105,  105,   44,   84,  105,  105,  105,  105,  105,  105,
     493
     494      105,   98,   70,    0
    494495    } ;
    495496
     
    539540    } ;
    540541
    541 static yyconst flex_int16_t yy_base[1069] =
     542static yyconst flex_int16_t yy_base[1079] =
    542543    {   0,
    543         0,   84, 2307, 2305,   94,    0,  177,  178,  179,  180,
    544      2319, 2845,  191, 2845,  197,   55, 2845, 2265,   60,  173,
    545      2845, 2845, 2845,   56,  188, 2845,  191,  189,  204,  216,
    546       275,    0, 2284, 2845,  216, 2283,  152,  344,  155,  220,
    547      2845,  159, 2845,  217,  226, 2845,  185,  154,  212,  251,
    548       237,  270,  235,  257,  241,  205,  193,  305,  314,  333,
    549       238,  228, 2845,  225, 2845, 2278,  402,  390, 2845, 2287,
    550      2845, 2255,  235, 2845,    0, 2845,  426,    0, 2845,  417,
    551      2845,  439,  451, 2845,  498, 2254,  264, 2845, 2845, 2845,
    552      2845, 2845, 2271, 2845, 2268, 2845, 2845, 2278,  559, 2845,
    553 
    554      2295, 2845,  438,  444,  511,  534,  289,  253,  197,  380,
    555       305,    0,  319,  280,  198,  322, 2845, 2845, 2845, 2265,
    556      2845, 2845, 2845, 2263, 2260,  218,  255, 2273,  298,  350,
    557       368,  312,  440,  398,  405, 2254,  441, 2203,  446, 2232,
    558      2845,  335, 2845, 2845,  468, 2226, 2223, 2845, 2196,  439,
    559       282,  433,  372,  281,  437,  434,  428,  570,  444,  466,
    560       464,  469,  475,  321,  492,  438,  471,  445,  474,  512,
    561       489,  503,  496,  521,  276,  515,  516, 2224,  526,  510,
    562       519,  525,  543,  522,  560,  553,  523,  561,  551,  544,
    563       599,  582,  593,  584, 2845, 2845,  660,  651, 2272,  666,
    564 
    565      2845,  678, 2845, 2219,  607, 2213, 2212,    0,  693, 2845,
    566      2845,  684, 2211, 2209, 2206,    0, 2227,  578,  608,  617,
    567       654,  679,  650,  683,  684,  687, 2224,  690,  691, 2201,
    568      2199, 2845,    0,  683,  710,  686,  700, 2179, 2230, 2845,
    569       730,  722,  427,  747,  756,  787,  770,  621, 2845, 2188,
    570      2161,    0,  795, 2205,  796,  700, 2845, 2181, 2156,  809,
    571      2845, 2845, 2188, 2845, 2845,  728,  733, 2165, 2163,  701,
    572      2159, 2158, 2156,    0, 2153,    0, 2122,  736,  746,  747,
    573       716,  689,  748,  566,  789,  659,  801,  751,  754,  785,
    574       776,  787,  808,  796,  739,  711,  806, 2152,  807,  815,
    575 
    576       817,  821,  809,  819,  827,  830,  831,  832,  833,  834,
    577       839,  840,  841,  842,  846,  853,  854,  844,  847,  855,
    578      2151,  860,  862,  861,  866,  864,  867,  869,  870,  872,
    579       873,  874,  878,  875,  883, 2149,  882,  928,  885,  888,
    580       894,  899,  892,  956,  958, 2143, 2140, 2139,    0, 2138,
    581         0,  945,  949, 2136,    0, 2133,    0, 2132,    0, 2153,
    582      2845,  930,  944, 2131, 2126,    0, 2125,    0, 2845,  959,
    583       979,  970, 2845,  985, 1025, 2124, 1001, 1047, 2122, 2845,
    584      2845,  943,  987, 1033,  986, 1072,  310, 1064,  987, 2845,
    585      2845, 2119, 2115, 2111,    0, 2109,    0, 2107,    0, 2104,
    586 
    587         0, 2845,  913,  947,  964,  966, 1005,  927, 1049,  939,
    588      1051,  968,  991,  986, 1041, 1053, 1003, 1059, 1063, 1066,
    589      1023, 1064, 1062, 1065,  978, 2105, 1072, 2103, 1078, 2100,
    590      1071, 1074, 1076, 1080, 1091, 1093, 1095, 2097, 1094, 2096,
    591      1082, 1098, 1099, 1100, 1101, 1105, 1106, 2095, 1107, 2093,
    592      1110, 1112, 1111, 1117, 1118, 1113, 1119, 1123, 1126, 1127,
    593      1129, 1130, 1131, 1140, 1142, 1143, 2090, 1144, 1147, 1195,
    594      2084,    0, 2083,    0, 2082,    0, 2080,    0, 1190, 2077,
    595         0, 2074,    0, 2073, 2072, 2070,    0, 2067,    0, 1197,
    596      2064, 1203, 1219, 1205, 1244, 1210, 1202, 1200, 2845, 1260,
    597 
    598      1278, 1271, 2075, 2050, 2060, 2057,    0, 2054,    0, 2053,
    599         0, 2052,    0, 2050,    0, 2047,    0, 1164, 1152, 2047,
    600      1184, 1182, 1226, 1157, 1227, 1196, 1254, 1146, 1237, 1255,
    601      1256, 1204, 1258, 1271, 1261, 1260, 1292, 1274, 1262, 1277,
    602      1278, 1280, 2046, 1186, 1289, 2045, 1279, 1282, 1290, 1295,
    603      2043, 1299, 1300, 1301, 1303, 2040, 1306, 1302, 2037, 1310,
    604      1311, 2036, 1309, 1312, 1315, 2035, 1220, 1314, 1316, 1322,
    605      1326, 1333, 2033, 1328, 1329, 2030, 1330, 1335, 2029, 2078,
    606      2023,    0, 2020,    0, 2019,    0, 2018,    0, 2016,    0,
    607      1983,    0, 1981,    0, 1980,    0, 1379, 1385, 1413, 1396,
    608 
    609      1977, 2845, 1402, 1351, 1389, 1403, 1974, 2845, 1973,    0,
    610      1972,    0, 1970,    0, 1967,    0,    0,    0, 1967,    0,
    611      1390, 1336, 1397, 1365, 1345, 1392, 1393, 1409, 1381, 1407,
    612      1412, 1414, 1419, 1420, 1422, 1424, 1427, 1431,  926, 1429,
    613      1432, 1438, 1433, 1435, 1440, 1966, 1437, 1441, 1445, 1965,
    614      1963, 1960, 1450, 1453, 1959, 1455, 1958, 1956, 1456, 1459,
    615      1953, 1952, 1951, 1949, 1942, 1940, 1458, 1461, 1939, 1464,
    616      1462, 1986, 2845, 1929,    0, 1925,    0,    0,    0, 1924,
    617         0,    0,    0, 2845,    0,    0,    0,    0, 1511, 1918,
    618      2845, 2845, 1517, 1917,    0, 1916,    0,    0,    0,    0,
    619 
    620      1914, 1474, 1468, 1914, 1443, 1493, 1498, 1476, 1504, 1505,
    621      1494, 1913, 1334, 1509, 1506, 1510, 1511, 1545, 1525, 1518,
    622      1543, 1530, 1523, 1529, 1531, 1534, 1535, 1539, 1912, 1910,
    623      1540, 1907, 1906, 1542, 1538, 1544, 1905, 1546, 1550,    0,
    624         0,    0, 1900, 1897, 1896, 1596,    0, 1895, 1893, 1890,
    625      1889, 1888, 1889, 1886, 1885, 1884, 1552, 1557, 1573, 1549,
    626      1551, 1553, 1575, 1555, 1577, 1582, 1607, 1882, 1583, 1879,
    627      1584, 1589, 1585, 1590, 1591, 1594, 1878, 1597, 1877, 1875,
    628      1872, 1598, 1871, 1870, 1865, 1862, 1861, 1860, 1858, 1851,
    629      1849, 1848, 1845, 1844, 1843, 1841, 1600, 1827, 1601, 1605,
    630 
    631      1608, 1602, 1609, 1610, 1818, 1614, 1629, 1615, 1817, 1604,
    632      1616, 1625, 1630, 1380, 1631, 1633, 1811, 1804, 1801, 1794,
    633      1792, 1791, 1770, 1769, 1768, 1761, 1759, 1758, 1716, 1716,
    634      1634, 1636, 1635, 1637, 1640, 1641, 1645, 1715, 1713, 1647,
    635      1712, 1711, 1648, 1652, 1653, 1654, 1703, 1701, 1700, 1698,
    636      1696, 1476, 1472, 1343, 1657, 1667, 1259, 1656, 1660, 1668,
    637      1150, 1671, 1675, 1676, 1031, 1027,  793,  752,  675, 1669,
    638      1677, 1680, 1681, 1682, 1684,  645,  607, 1686,  487,  441,
    639      1688, 1690,  394,  357, 1693, 1694, 1695, 1697, 1696, 1698,
    640      1700,  233,  137, 2845, 1773, 1786, 1799, 1809, 1819, 1832,
    641 
    642      1842, 1855, 1868, 1881, 1889, 1899, 1906, 1913, 1920, 1927,
    643      1934, 1941, 1948, 1955, 1962, 1969, 1973, 1981, 1987, 1994,
    644      2001, 2008, 2015, 2018, 2025, 2031, 2044, 2057, 2064, 2071,
    645      2078, 2085, 2088, 2095, 2098, 2105, 2108, 2115, 2118, 2125,
    646      2128, 2135, 2138, 2145, 2148, 2155, 2163, 2170, 2177, 2184,
    647      2191, 2194, 2201, 2204, 2211, 2214, 2221, 2227, 2240, 2247,
    648      2254, 2257, 2264, 2267, 2274, 2277, 2284, 2287, 2294, 2297,
    649      2304, 2307, 2314, 2321, 2324, 2331, 2334, 2341, 2348, 2355,
    650      2358, 2365, 2368, 2375, 2378, 2385, 2388, 2395, 2398, 2405,
    651      2411, 2424, 2431, 2438, 2441, 2448, 2451, 2458, 2461, 2468,
    652 
    653      2471, 2478, 2481, 2488, 2491, 2498, 2501, 2508, 2511, 2518,
    654      2525, 2528, 2535, 2538, 2545, 2548, 2555, 2558, 2561, 2567,
    655      2574, 2583, 2590, 2597, 2600, 2607, 2610, 2613, 2619, 2626,
    656      2629, 2632, 2635, 2638, 2641, 2644, 2647, 2654, 2657, 2664,
    657      2667, 2670, 2673, 2676, 2686, 2693, 2696, 2699, 2702, 2709,
    658      2716, 2723, 2726, 2733, 2740, 2747, 2754, 2761, 2768, 2775,
    659      2782, 2789, 2796, 2803, 2810, 2817, 2824, 2831
     544        0,   84, 2323, 2322,   94,    0,  177,  178,  179,  180,
     545     2338, 2866,  191, 2866,  197,   55, 2866, 2283,   60,  173,
     546     2866, 2866, 2866,   56,  188, 2866,  191,  189,  204,  216,
     547      275,    0, 2300, 2866,  216, 2298,  152,  344,  155,  220,
     548     2866,  159, 2866,  217,  226, 2866,  185,  154,  212,  251,
     549      237,  270,  235,  257,  241,  279,  193,  305,  314,  333,
     550      238,  228,  227, 2866,  225, 2866, 2295,  402,  390, 2866,
     551     2306, 2866, 2273,  235, 2866,    0, 2866,  426,    0, 2866,
     552      417, 2866,  439,  451, 2866,  498, 2270,  264, 2866, 2866,
     553     2866, 2866, 2866, 2286, 2866, 2285, 2866, 2866, 2297,  559,
     554
     555     2866, 2313, 2866,  438,  444,  511,  534,  289,  253,  197,
     556      380,  305,    0,  319,  280,  198,  322, 2866, 2866, 2866,
     557     2281, 2866, 2866, 2866, 2278, 2277,  218,  312, 2292,  350,
     558      459,  368,  398,  440,  405,  448, 2272,  441, 2219,  458,
     559     2247, 2866,  335, 2866, 2866,  321, 2243, 2242, 2866, 2214,
     560      444,  297,  433,  372,  425,  454,  434,  461,  570,  455,
     561      468,  385,  474,  475,  494,  492,  489,  464,  488,  491,
     562      513,  503,  430,  521,  517,  519,  516,  522, 2240,  526,
     563      523,  276,  460,  524,  542,  555,  554,  561,  325,  558,
     564      584,  552,  600,  586,  593,  588,  595, 2866, 2866,  667,
     565
     566      655, 2287,  682, 2866,  688, 2866, 2236,  590, 2232, 2230,
     567        0,  648, 2866, 2866,  675, 2227, 2224, 2223,    0, 2246,
     568      578,  631,  654,  685,  698,  660,  689,  670,  692, 2242,
     569      695,  701, 2200, 2198, 2866,    0,  693,  720,  685,  711,
     570     2197, 2247, 2866,  737,  745,  666,  757,  763,  797,  780,
     571      599, 2866, 2203, 2178,    0,  805, 2224,  806,  617, 2866,
     572     2199, 2172,  819, 2866, 2866, 2203, 2866, 2866,  707,  722,
     573     2182, 2182,  699, 2177, 2174, 2171,    0, 2170,    0, 2141,
     574      743,  724,  739,  689,  741,  720,  623,  759,  762,  804,
     575      681,  795,  749,  746,  799,  801,  765,  784,  803,  811,
     576
     577     2170,  814,  818,  827,  831,  817,  821,  833,  835,  841,
     578      842,  834,  843,  844,  845,  847,  849,  857,  858,  860,
     579      851,  859,  866, 2167,  867,  868,  869,  871,  873,  874,
     580      763,  875,  876,  880,  881,  884,  887,  888,  885, 2164,
     581      891,  936,  894,  897,  905,  899,  901,  902,  965,  961,
     582     2160, 2159, 2157,    0, 2154,    0,  952,  956, 2153,    0,
     583     2152,    0, 2150,    0, 2169, 2866,  951,  952, 2148, 2145,
     584        0, 2143,    0, 2866,  967,  986,  978, 2866,  992, 1032,
     585     2140, 1008, 1054, 2136, 2866, 2866,  915,  951, 1040,  993,
     586     1079,  956, 1071,  994, 2866, 2866, 2132, 2130, 2128,    0,
     587
     588     2125,    0, 2123,    0, 2121,    0, 2866,  935,  969,  973,
     589      968, 1012,  975, 1056,  992, 1058,  997, 1032,  993, 1000,
     590     1060, 1061, 1066, 1070, 1073, 1030, 1071, 1069, 1072, 1078,
     591     2121,  700, 2118, 1085, 2117, 1079, 1081, 1089, 1087, 1098,
     592     1096, 1099, 2116, 1101, 2114, 1105, 1106, 1107, 1109, 1112,
     593     1113, 1114, 2111, 1115, 2108, 1117, 1119, 1120, 1118, 1124,
     594     1126, 1121, 1136, 1130, 1134, 1135, 1149, 1137, 1138, 1150,
     595     1152, 1153, 2107, 1151, 1154, 1167, 1205, 2103,    0, 2101,
     596        0, 2098,    0, 2095,    0, 1204, 2094,    0, 2093,    0,
     597     2091, 2088, 2085,    0, 2084,    0, 1208, 2083, 1214, 1230,
     598
     599     1216, 1255, 1221, 1172, 1169, 2866, 1271, 1289, 1282, 2093,
     600     2066, 2075, 2074,    0, 2073,    0, 2071,    0, 2068,    0,
     601     2065,    0, 2064,    0, 1190, 1159, 2066, 1193, 1195, 1197,
     602     1212, 1237, 1231, 1265, 1248, 1266, 1267, 1213, 1268, 1269,
     603     1283, 1270, 1271,  234, 1285, 1273, 1274, 1287, 1293, 2064,
     604     1306, 1301, 2061, 1290, 1303, 1305, 1308, 2058, 1312, 1309,
     605     1311, 1313, 2057, 1314, 1319, 2056, 1316, 1322, 2054, 2051,
     606     1315, 1327, 1330, 2050, 1333, 1332, 1336, 1334, 1338, 1345,
     607     2049, 1335, 1348, 2047, 1346, 1349, 2044, 1351, 2093, 2039,
     608        0, 2037,    0, 2004,    0, 2002,    0, 2001,    0, 1998,
     609
     610        0, 1995,    0, 1994,    0, 1394, 1404, 1428, 1415, 1993,
     611     2866, 1421, 1370, 1391, 1419, 1991, 2866, 1988,    0, 1985,
     612        0, 1984,    0, 1983,    0,    0,    0, 1984,    0, 1352,
     613     1406, 1408, 1359, 1354, 1409, 1415, 1412, 1411, 1423, 1433,
     614     1425, 1430, 1435, 1437, 1439, 1448, 1442, 1449, 1440, 1444,
     615     1453, 1450, 1452, 1456, 1981, 1458, 1460, 1463, 1980, 1979,
     616     1977, 1466, 1467, 1974, 1470, 1973, 1972, 1469, 1473, 1970,
     617     1963, 1961, 1960, 1957, 1953, 1475, 1479, 1949, 1476, 1477,
     618     1945, 1992, 2866, 1938,    0, 1937,    0,    0,    0, 1938,
     619        0,    0,    0, 2866,    0,    0,    0,    0, 1525, 1932,
     620
     621     2866, 2866, 1531, 1931,    0, 1930,    0,    0,    0,    0,
     622     1928, 1488, 1483, 1928, 1491, 1507, 1518, 1490, 1519, 1521,
     623     1508, 1927, 1525, 1529, 1527, 1541, 1530, 1384, 1543, 1539,
     624     1558, 1547, 1549, 1512, 1545, 1552, 1553, 1554, 1926, 1924,
     625     1557, 1921, 1920, 1556, 1537, 1560, 1919, 1561, 1564,    0,
     626        0,    0, 1914, 1911, 1910, 1612,    0, 1909, 1907, 1904,
     627     1903, 1902, 1903, 1900, 1899, 1898, 1568, 1572, 1566, 1577,
     628     1590, 1570, 1578, 1579, 1591, 1596, 1625, 1896, 1598, 1893,
     629     1599, 1603, 1604, 1608, 1606, 1612, 1892, 1613, 1891, 1889,
     630     1886, 1614, 1885, 1884, 1879, 1872, 1870, 1869, 1866, 1865,
     631
     632     1864, 1862, 1845, 1836, 1835, 1832, 1616, 1828, 1617, 1622,
     633     1620, 1619, 1624, 1626, 1825, 1628, 1644, 1630, 1818, 1631,
     634     1639, 1645, 1647, 1634, 1649, 1651, 1813, 1812, 1791, 1790,
     635     1789, 1782, 1780, 1779, 1737, 1735, 1733, 1732, 1730, 1732,
     636     1652, 1654, 1655, 1657, 1659, 1662, 1663, 1731, 1729, 1668,
     637     1727, 1724, 1669, 1670, 1664, 1675, 1719, 1718, 1671, 1629,
     638     1564, 1468, 1350, 1269, 1678, 1681, 1239, 1682, 1688, 1689,
     639     1238, 1690, 1692, 1696, 1206, 1171, 1157, 1035, 1031, 1691,
     640     1697, 1700, 1704, 1702, 1706,  998,  560, 1701,  527,  395,
     641     1707, 1710,  357,  300, 1708, 1713, 1715, 1718, 1716, 1719,
     642
     643     1720,  233,  137, 2866, 1794, 1807, 1820, 1830, 1840, 1853,
     644     1863, 1876, 1889, 1902, 1910, 1920, 1927, 1934, 1941, 1948,
     645     1955, 1962, 1969, 1976, 1983, 1990, 1994, 2002, 2008, 2015,
     646     2022, 2029, 2036, 2039, 2046, 2052, 2065, 2078, 2085, 2092,
     647     2099, 2106, 2109, 2116, 2119, 2126, 2129, 2136, 2139, 2146,
     648     2149, 2156, 2159, 2166, 2169, 2176, 2184, 2191, 2198, 2205,
     649     2212, 2215, 2222, 2225, 2232, 2235, 2242, 2248, 2261, 2268,
     650     2275, 2278, 2285, 2288, 2295, 2298, 2305, 2308, 2315, 2318,
     651     2325, 2328, 2335, 2342, 2345, 2352, 2355, 2362, 2369, 2376,
     652     2379, 2386, 2389, 2396, 2399, 2406, 2409, 2416, 2419, 2426,
     653
     654     2432, 2445, 2452, 2459, 2462, 2469, 2472, 2479, 2482, 2489,
     655     2492, 2499, 2502, 2509, 2512, 2519, 2522, 2529, 2532, 2539,
     656     2546, 2549, 2556, 2559, 2566, 2569, 2576, 2579, 2582, 2588,
     657     2595, 2604, 2611, 2618, 2621, 2628, 2631, 2634, 2640, 2647,
     658     2650, 2653, 2656, 2659, 2662, 2665, 2668, 2675, 2678, 2685,
     659     2688, 2691, 2694, 2697, 2707, 2714, 2717, 2720, 2723, 2730,
     660     2737, 2744, 2747, 2754, 2761, 2768, 2775, 2782, 2789, 2796,
     661     2803, 2810, 2817, 2824, 2831, 2838, 2845, 2852
    660662    } ;
    661663
    662 static yyconst flex_int16_t yy_def[1069] =
     664static yyconst flex_int16_t yy_def[1079] =
    663665    {   0,
    664       894,    1,  895,  895,  894,    5,  896,  896,  897,  897,
    665       894,  894,  894,  894,  894,  894,  894,  898,  894,  894,
    666       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    667       894,   31,  894,  894,  894,  894,  894,  894,  899,  898,
    668       894,  894,  894,  894,  898,  894,  898,  898,  898,  898,
    669       898,  898,  898,  898,  898,  898,  898,  898,  898,  898,
    670       898,  898,  894,  894,  894,  894,  894,  900,  894,  894,
    671       894,  901,  894,  894,  902,  894,  894,  903,  894,  894,
    672       894,  894,  894,  894,  894,  898,  894,  894,  894,  894,
    673       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    674 
    675       904,  894,  894,   30,  894,  894,  894,  894,  905,   30,
    676       894,   31,  894,  894,   31,  894,  894,  894,  894,  894,
    677       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    678       894,  894,  894,  894,  894,  894,  894,  894,  894,  906,
    679       894,  894,  894,  894,  898,  907,  908,  894,  894,  898,
    680       898,  898,  898,  898,  898,  898,  898,  898,  898,  898,
    681       898,  898,  898,  898,  898,  898,  898,  898,  898,  898,
    682       898,  898,  898,  898,  898,  898,  898,  898,  898,  898,
    683       898,  898,  898,  898,  898,  898,  898,  898,  898,  898,
    684       898,  898,  898,  898,  894,  894,  894,  900,  900,  900,
    685 
    686       894,  900,  894,  901,  894,  909,  910,  902,  894,  894,
    687       894,  894,  911,  912,  913,  903,  894,  894,  894,  894,
    688       894,  894,  894,  894,  894,  894,  894,  894,  894,  914,
    689       915,  894,   99,  894,  894,  894,  894,   99,  904,  894,
    690        99,  110,  242,  894,  894,  894,  894,  894,  894,  894,
    691       894,  916,  917,  918,  894,  894,  894,  894,  894,  894,
    692       894,  894,  894,  894,  894,  894,  894,  894,  919,  894,
    693       920,  921,  922,  923,  924,  925,  894,  926,  926,  926,
    694       926,  926,  926,  926,  926,  926,  926,  926,  926,  926,
    695       926,  926,  926,  926,  926,  926,  926,  926,  926,  926,
    696 
    697       926,  926,  926,  926,  926,  926,  926,  926,  926,  926,
    698       926,  926,  926,  926,  926,  926,  926,  926,  926,  926,
    699       926,  926,  926,  926,  926,  926,  926,  926,  926,  926,
    700       926,  926,  926,  926,  926,  926,  926,  926,  926,  926,
    701       926,  926,  926,  927,  928,  929,  930,  931,  932,  933,
    702       934,  894,  894,  935,  936,  937,  938,  939,  940,  894,
    703       894,  894,  894,  894,  941,  942,  943,  944,  894,  894,
    704       894,  894,  894,  894,  894,  375,  894,  371,  378,  894,
    705       894,  945,  946,  947,  894,  894,  894,  947,  894,  894,
    706       894,  948,  949,  950,  951,  952,  953,  954,  955,  956,
    707 
    708       957,  894,  958,  958,  958,  958,  958,  958,  958,  958,
    709       958,  958,  958,  958,  958,  958,  958,  958,  958,  958,
    710       958,  958,  958,  958,  958,  958,  958,  958,  958,  958,
    711       958,  958,  958,  958,  958,  958,  958,  958,  958,  958,
    712       958,  958,  958,  958,  958,  958,  958,  958,  958,  958,
    713       958,  958,  958,  958,  958,  958,  958,  958,  958,  958,
    714       958,  958,  958,  958,  958,  958,  958,  958,  958,  959,
    715       960,  961,  962,  963,  964,  965,  966,  967,  894,  968,
    716       969,  970,  971,  972,  972,  973,  974,  975,  976,  894,
    717       490,  894,  894,  977,  894,  977,  894,  894,  894,  894,
    718 
    719       894,  894,  894,  894,  978,  979,  980,  981,  982,  983,
    720       984,  985,  986,  987,  988,  989,  990,  991,  991,  991,
    721       991,  991,  991,  991,  991,  991,  991,  991,  991,  991,
    722       991,  991,  991,  991,  991,  991,  991,  991,  991,  991,
    723       991,  991,  991,  991,  991,  991,  991,  991,  991,  991,
    724       991,  991,  991,  991,  991,  991,  991,  991,  991,  991,
    725       991,  991,  991,  991,  991,  991,  991,  991,  991,  991,
    726       991,  991,  991,  991,  991,  991,  991,  991,  991,  992,
    727       993,  994,  995,  996,  997,  998,  999, 1000, 1001, 1002,
    728      1003, 1004, 1005, 1006, 1007, 1008,  894,  894,  894,  894,
    729 
    730      1009,  894,  599,  894,  894,  894,  603,  894, 1010, 1011,
    731      1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021,
    732      1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020,
    733      1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020,
    734      1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020,
    735      1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020,
    736      1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020, 1020,
    737      1020, 1022,  894, 1023, 1024, 1025, 1026, 1027, 1028, 1029,
    738      1030, 1031, 1032,  894, 1033, 1034, 1035, 1036,  894,  689,
    739       894,  894,  894, 1037, 1038, 1039, 1040, 1041, 1042, 1043,
    740 
    741      1044, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    742      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    743      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    744      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1046,
    745      1047, 1048, 1049, 1050, 1051,  894, 1052, 1037, 1039, 1053,
    746      1054, 1044, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    747      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    748      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    749      1045, 1045, 1045, 1045, 1055, 1056, 1049, 1057, 1050, 1058,
    750      1051, 1059, 1060, 1053, 1061, 1054, 1045, 1045, 1045, 1045,
    751 
    752      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    753      1045, 1045, 1045, 1045, 1045, 1045, 1062, 1055, 1063, 1056,
    754      1064, 1057, 1065, 1058, 1066, 1059, 1067, 1060, 1061, 1045,
    755      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    756      1045, 1045, 1045, 1045, 1045, 1045, 1068, 1062, 1063, 1064,
    757      1065, 1039, 1066, 1067, 1045, 1045, 1045, 1045, 1045, 1045,
    758      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1068, 1039, 1045,
    759      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    760      1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045,
    761      1045, 1045, 1045,    0,  894,  894,  894,  894,  894,  894,
    762 
    763       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    764       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    765       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    766       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    767       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    768       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    769       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    770       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    771       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    772       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    773 
    774       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    775       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    776       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    777       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    778       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    779       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    780       894,  894,  894,  894,  894,  894,  894,  894
     666      904,    1,  905,  905,  904,    5,  906,  906,  907,  907,
     667      904,  904,  904,  904,  904,  904,  904,  908,  904,  904,
     668      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     669      904,   31,  904,  904,  904,  904,  904,  904,  909,  908,
     670      904,  904,  904,  904,  908,  904,  908,  908,  908,  908,
     671      908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
     672      908,  908,  908,  904,  904,  904,  904,  904,  910,  904,
     673      904,  904,  911,  904,  904,  912,  904,  904,  913,  904,
     674      904,  904,  904,  904,  904,  904,  908,  904,  904,  904,
     675      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     676
     677      904,  914,  904,  904,   30,  904,  904,  904,  904,  915,
     678       30,  904,   31,  904,  904,   31,  904,  904,  904,  904,
     679      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     680      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     681      916,  904,  904,  904,  904,  908,  917,  918,  904,  904,
     682      908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
     683      908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
     684      908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
     685      908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
     686      908,  908,  908,  908,  908,  908,  908,  904,  904,  904,
     687
     688      910,  910,  910,  904,  910,  904,  911,  904,  919,  920,
     689      912,  904,  904,  904,  904,  921,  922,  923,  913,  904,
     690      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     691      904,  904,  924,  925,  904,  100,  904,  904,  904,  904,
     692      100,  914,  904,  100,  111,  245,  904,  904,  904,  904,
     693      904,  904,  904,  904,  926,  927,  928,  904,  904,  904,
     694      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     695      904,  929,  904,  930,  931,  932,  933,  934,  935,  904,
     696      936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
     697      936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
     698
     699      936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
     700      936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
     701      936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
     702      936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
     703      936,  936,  936,  936,  936,  936,  936,  936,  937,  938,
     704      939,  940,  941,  942,  943,  944,  904,  904,  945,  946,
     705      947,  948,  949,  950,  904,  904,  904,  904,  904,  951,
     706      952,  953,  954,  904,  904,  904,  904,  904,  904,  904,
     707      380,  904,  376,  383,  904,  904,  955,  956,  957,  904,
     708      904,  904,  957,  904,  904,  904,  958,  959,  960,  961,
     709
     710      962,  963,  964,  965,  966,  967,  904,  968,  968,  968,
     711      968,  968,  968,  968,  968,  968,  968,  968,  968,  968,
     712      968,  968,  968,  968,  968,  968,  968,  968,  968,  968,
     713      968,  968,  968,  968,  968,  968,  968,  968,  968,  968,
     714      968,  968,  968,  968,  968,  968,  968,  968,  968,  968,
     715      968,  968,  968,  968,  968,  968,  968,  968,  968,  968,
     716      968,  968,  968,  968,  968,  968,  968,  968,  968,  968,
     717      968,  968,  968,  968,  968,  968,  969,  970,  971,  972,
     718      973,  974,  975,  976,  977,  904,  978,  979,  980,  981,
     719      982,  982,  983,  984,  985,  986,  904,  497,  904,  904,
     720
     721      987,  904,  987,  904,  904,  904,  904,  904,  904,  904,
     722      904,  988,  989,  990,  991,  992,  993,  994,  995,  996,
     723      997,  998,  999, 1000, 1001, 1001, 1001, 1001, 1001, 1001,
     724     1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001,
     725     1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001,
     726     1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001,
     727     1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001,
     728     1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001,
     729     1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1002, 1003,
     730     1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013,
     731
     732     1014, 1015, 1016, 1017, 1018,  904,  904,  904,  904, 1019,
     733      904,  608,  904,  904,  904,  612,  904, 1020, 1021, 1022,
     734     1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1030,
     735     1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030,
     736     1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030,
     737     1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030,
     738     1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030,
     739     1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030,
     740     1030, 1032,  904, 1033, 1034, 1035, 1036, 1037, 1038, 1039,
     741     1040, 1041, 1042,  904, 1043, 1044, 1045, 1046,  904,  699,
     742
     743      904,  904,  904, 1047, 1048, 1049, 1050, 1051, 1052, 1053,
     744     1054, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     745     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     746     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     747     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1056,
     748     1057, 1058, 1059, 1060, 1061,  904, 1062, 1047, 1049, 1063,
     749     1064, 1054, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     750     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     751     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     752     1055, 1055, 1055, 1055, 1065, 1066, 1059, 1067, 1060, 1068,
     753
     754     1061, 1069, 1070, 1063, 1071, 1064, 1055, 1055, 1055, 1055,
     755     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     756     1055, 1055, 1055, 1055, 1055, 1055, 1072, 1065, 1073, 1066,
     757     1074, 1067, 1075, 1068, 1076, 1069, 1077, 1070, 1071, 1055,
     758     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     759     1055, 1055, 1055, 1055, 1055, 1055, 1078, 1072, 1073, 1074,
     760     1075, 1049, 1076, 1077, 1055, 1055, 1055, 1055, 1055, 1055,
     761     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1078, 1049, 1055,
     762     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     763     1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1055,
     764
     765     1055, 1055, 1055,    0,  904,  904,  904,  904,  904,  904,
     766      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     767      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     768      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     769      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     770      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     771      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     772      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     773      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     774      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     775
     776      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     777      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     778      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     779      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     780      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     781      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     782      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     783      904,  904,  904,  904,  904,  904,  904,  904
    781784    } ;
    782785
    783 static yyconst flex_int16_t yy_nxt[2931] =
     786static yyconst flex_int16_t yy_nxt[2952] =
    784787    {   0,
    785788       12,   13,   14,   15,   15,   15,   13,   16,   17,   12,
     
    791794       50,   51,   52,   53,   18,   54,   18,   55,   18,   18,
    792795       56,   18,   57,   58,   59,   60,   61,   62,   18,   18,
    793        18,   63,   64,   65,   66,   67,   84,   92,   85,   85,
    794        67,   88,   89,   68,   71,   71,   71,   71,   71,   71,
    795 
    796        71,   71,   71,   71,   72,   71,   71,   71,   71,   71,
    797        71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
    798        71,   71,   71,   71,   71,   71,   71,   71,   71,   72,
     796       63,   64,   65,   66,   67,   68,   85,   93,   86,   86,
     797       68,   89,   90,   69,   72,   72,   72,   72,   72,   72,
     798
     799       72,   72,   72,   72,   73,   72,   72,   72,   72,   72,
    799800       72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    800        72,   72,   72,   72,   72,   71,   73,   71,   71,   72,
    801        74,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    802        72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    803        72,   72,   72,   72,   72,   71,   71,   71,   71,   76,
    804        76,   79,   79,  123,  124,   90,  141,   79,   79,   87,
    805        76,   76,   80,   81,   82,   82,   82,   80,   82,   81,
    806 
    807        83,   83,   83,   82,   91,   93,   87,  142,  146,   98,
    808        95,   99,   99,   99,   99,   99,   99,  252,  894,   94,
    809       100,   85,   96,   97,   85,  101,  161,  118,  143,   77,
    810        77,   77,   77,  144,  147,  102,  103,   87,  104,  104,
    811       104,  104,  105,  105,  119,   87,  120,  121,  148,  263,
    812       149,  264,  254,  260,  183,  106,  195,   87,  159,  107,
    813       160,  150,  151,  152,   87,  108,  109,  153,  154,  162,
    814       155,  110,   87,  156,  157,  145,  163,  106,   87,  182,
    815        87,  158,  164,  111,  206,   87,  263,   87,  264,   87,
    816        87,  108,  194,   87,  109,  103,  250,  112,  112,  112,
    817 
    818       112,  112,  112,   87,  169,  177,  170,  196,  193,   87,
    819       207,  180,  165,  230,  106,  171,  166,  181,  113,  178,
    820       251,  167,   87,  258,  114,  168,  179,  172,   87,  263,
    821       115,  264,  248,   87,   87,  173,  106,  174,  249,  231,
    822       175,  143,  116,  263,  176,  264,  144,  259,  317,  283,
    823       114,  125,  280,  503,  249,  126,  127,   87,  128,  191,
    824       129,  130,  256,  131,  249,  132,   87,  265,  257,  184,
    825       185,  257,  248,   87,  133,  134,  135,  504,  188,  186,
    826       249,  263,  187,  264,  271,   87,  189,  265,  145,  256,
    827       305,  200,  201,  190,  257,  136,  200,  257,  137,  263,
    828 
    829       894,  264,  192,  197,   81,   82,   82,   82,  197,   87,
    830       272,  198,  202,  202,  202,  202,  202,  202,   80,   81,
    831        82,   82,   82,   80,   87,  138,  139,  209,  210,  263,
    832       894,  264,  209,  282,  211,  255,  263,  267,  264,  211,
    833        82,   81,   82,   82,   82,   82,   87,  894,  212,  212,
    834       212,  212,   82,   81,   83,   83,   83,   82,  894,  211,
    835       241,  241,  241,  241,  241,  241,  242,  242,  242,  242,
    836       266,  263,  263,  264,  264,  213,  143,  263,  211,  264,
    837        87,  144,  377,  211,  211,   87,   87,  211,  211,   87,
    838        87,   87,  286,   87,  894,  211,   87,   87,  211,  243,
    839 
    840       211,  214,  211,  281,  215,  217,  278,  284,  285,  218,
    841       219,  307,  298,  279,  220,  221,   87,  222,   87,  223,
    842        87,   87,  894,   87,  309,  300,   87,   87,  224,  225,
    843       226,  103,  303,  105,  105,  105,  105,  105,  105,   87,
    844       299,   87,  301,  302,   87,  304,  308,  310,   87,  227,
    845       106,  245,  228,  245,  306,   87,  246,  246,  246,  246,
    846       246,  246,   87,  313,   87,  315,  244,   87,   87,  311,
    847       314,   87,  106,   87,   87,   87,  323,   87,   87,  322,
    848       229,  233,  233,  233,  233,  233,  233,  312,  333,  247,
    849       319,  316,  328,  320,  318,   87,   87,  234,  235,  236,
    850 
    851       321,  237,  236,   87,  324,   87,  325,  143,  335,  360,
    852       331,  361,   87,   87,  238,  337,  326,  327,   87,  236,
    853       235,  236,   87,  329,  237,  332,  236,  287,  288,  289,
    854       336,  290,  291,  334,   87,  292,   87,  293,  409,  360,
    855       330,  361,  294,  295,  296,   87,  297,  339,  360,  343,
    856       361,   87,  200,  201,  338,  340,  346,  200,  341,   87,
    857       342,  197,   81,   82,   82,   82,  197,  200,  201,  198,
    858       380,  361,  200,  202,  202,  202,  202,  202,  202,  344,
    859       201,  360,  347,  361,  344,  360,  345,  361,  202,  202,
    860       202,  202,  202,  202,  209,  210,  380,   87,  361,  209,
    861 
    862       202,  202,  202,  202,  202,  202,  352,  352,  352,  352,
    863       360,   87,  361,  362,  360,  360,  361,  361,  360,  363,
    864       361,  360,  360,  361,  361,  369,  369,  370,  369,  370,
    865       894,  411,  371,  371,  371,  371,  371,  371,  373,  353,
    866       373,   87,  103,  373,  242,  242,  242,  242,  369,  390,
    867       392,  369,  375,  375,  375,  375,  375,  375,  407,  263,
    868       373,  264,  373,   87,  263,  372,  264,  373,   87,  105,
    869       105,  105,  105,  105,  105,  390,  393,  243,  246,  246,
    870       246,  246,  246,  246,  406,  376,  106,  245,   87,  245,
    871       424,   87,  246,  246,  246,  246,  246,  246,   87,   87,
    872 
    873        87,  403,  255,   87,  423,  408,   87,  894,  106,  378,
    874       378,  378,  378,  378,  378,  383,  404,  405,  105,  105,
    875       105,  105,  105,  105,  416,  234,  415,  236,   87,  237,
    876       236,  112,  112,  112,  112,  112,  112,   87,  385,   87,
    877       386,   87,  379,  418,  387,   87,  410,  236,   87,  236,
    878       388,  255,  237,   87,  236,  419,  420,  422,   87,   87,
    879        87,   87,  389,  417,  260,  421,  386,   87,  412,   87,
    880       387,   87,  427,   87,  413,  414,  425,  426,  428,   87,
    881       429,  430,   87,   87,   87,   87,   87,  434,  435,  431,
    882       436,   87,   87,   87,   87,  438,   87,  439,   87,   87,
    883 
    884       432,  433,  441,  443,  437,   87,   87,   87,  440,  442,
    885       444,  445,   87,   87,   87,  447,   87,  448,   87,   87,
    886       449,   87,   87,  450,   87,   87,   87,   87,  446,  451,
    887        87,  453,  452,  458,   87,   87,  143,   87,  454,  457,
    888        87,  456,  455,  464,   87,  462,   87,  459,  463,  460,
    889       721,   87,  461,  466,  467,  465,  468,  344,  201,  469,
    890       201,  360,  344,  361,  345,   87,  199,  211,  211,  211,
    891       211,  352,  352,  352,  352,  360,  518,  361,   87,   87,
    892        87,  371,  371,  371,  371,  371,  371,  370,  495,  370,
    893       523,   87,  371,  371,  371,  371,  371,  371,  496,   87,
    894 
    895       479,  490,  490,  490,  490,  490,  490,  233,  233,  233,
    896       233,  233,  233,  525,  495,  519,   87,  234,   87,  236,
    897        87,  237,  236,  242,  242,  242,  242,  105,  105,  498,
    898        87,  520,  495,  527,  491,  499,  499,  521,   87,  236,
    899       374,  236,  497,   87,  237,  542,  236,  375,  375,  375,
    900       375,  375,  375,  383,  498,   87,  377,   87,  495,  528,
    901       529,  499,  499,  234,  235,  236,  522,  237,  236,  378,
    902       378,  378,  378,  378,  378,   87,  385,  533,  386,   87,
    903       376,  538,  387,   87,  894,  236,  235,  236,  388,  500,
    904       237,  500,  236,   87,  501,  501,  501,  501,  501,  501,
    905 
    906       389,   87,  379,   87,  386,   87,  530,  385,  387,  386,
    907       524,   87,  526,  387,   87,   87,   87,   87,   87,  505,
    908       535,  531,  532,   87,   87,  540,   87,  502,   87,  534,
    909        87,  389,   87,  536,   87,  386,  541,  539,  543,  387,
    910       537,  547,  544,   87,  545,   87,   87,   87,  546,  549,
    911        87,   87,   87,   87,  553,  548,  551,   87,   87,   87,
    912       550,  552,   87,   87,   87,   87,  555,  559,  557,   87,
    913        87,   87,  554,  562,  556,   87,  560,  558,   87,   87,
    914       567,   87,   87,   87,  563,  561,  570,  566,  571,  564,
    915       565,  569,   87,  568,   87,   87,   87,  201,   87,   87,
    916 
    917       574,  630,   87,  580,   87,  573,  577,  572,  579,   87,
    918       575,  576,  211,  211,  211,  211,   87,  622,  578,  490,
    919       490,  490,  490,  490,  490,  375,  375,  375,  375,  375,
    920       375,  626,  645,  621,   87,  234,   87,  236,   87,  237,
    921       236,  378,  378,  378,  378,  378,  378,  495,   87,  602,
    922       495,  623,  491,  628,  624,  495,   87,  236,  492,  236,
    923       496,  598,  237,  598,  236,  601,  599,  599,  599,  599,
    924       599,  599,   87,  495,  493,  602,  495,  634,   87,   87,
    925       662,  495,  501,  501,  501,  501,  501,  501,  500,   87,
    926       500,  625,  627,  501,  501,  501,  501,  501,  501,  600,
    927 
    928       603,  603,  603,  603,  603,  603,   87,   87,   87,  631,
    929        87,   87,   87,   87,   87,  639,  604,  629,  605,  635,
    930       606,  605,  632,   87,  637,  638,   87,  633,  636,   87,
    931        87,   87,   87,  607,   87,  640,  641,  644,  605,  643,
    932       605,   87,   87,  606,   87,  605,  642,   87,  647,  648,
    933       646,   87,   87,   87,   87,   87,  650,  649,   87,  656,
    934       651,   87,   87,   87,   87,  653,   87,   87,   87,  652,
    935       654,  657,  658,  655,   87,  664,  663,  660,   87,  667,
    936        87,   87,   87,  659,  661,   87,   87,   87,   87,  668,
    937       666,  669,  762,  691,  691,  704,  665,   87,  894,  670,
    938 
    939       671,  490,  490,  490,  490,  490,  490,  599,  599,  599,
    940       599,  599,  599,  598,  707,  598,  691,   87,  599,  599,
    941       599,  599,  599,  599,  603,  603,  603,  603,  603,  603,
    942       706,  691,   87,   87,  597,  689,  689,  689,  689,  689,
    943       689,  692,   87,  692,   87,   87,  692,  702,  844,   87,
    944       711,  604,  709,  605,  691,  606,  605,  607,  705,   87,
    945       703,   87,  712,  692,   87,  692,   87,  708,  690,  710,
    946       692,   87,   87,  605,   87,  605,   87,  713,  606,   87,
    947       605,   87,  719,   87,   87,   87,  715,   87,  714,   87,
    948        87,  717,   87,   87,  716,   87,  722,   87,  718,  724,
    949 
    950       720,  727,   87,  725,  723,   87,  730,   87,   87,  726,
    951        87,   87,  728,   87,   87,  729,   87,  734,  735,  736,
    952        87,  755,  731,  737,  733,  738,   87,  894,   87,  739,
    953       754,  869,  732,  689,  689,  689,  689,  689,  689,  603,
    954       603,  603,  603,  603,  603,   87,   87,  753,  758,  604,
    955        87,  605,  756,  606,  605,  757,   87,   87,   87,  759,
    956       760,   87,   87,   87,  761,  765,  690,  764,  767,  770,
    957        87,  605,  693,  605,  763,   87,  606,   87,  605,  769,
    958       768,   87,   87,   87,  766,  771,   87,   87,  772,  773,
    959        87,   87,   87,  774,   87,   87,   87,   87,   87,  775,
    960 
    961       777,   87,   87,   87,   87,   87,  783,   87,  776,   87,
    962       778,  784,  781,  801,  780,  779,  800,  782,  689,  689,
    963       689,  689,  689,  689,  797,   87,  798,   87,  802,   87,
    964       799,  807,  805,  804,   87,   87,   87,   87,  808,  809,
    965       811,   87,   87,   87,  803,  812,   87,  806,  810,   87,
    966        87,  746,   87,   87,   87,  838,   87,   87,  813,   87,
    967        87,   87,   87,  833,  835,  836,   87,   87,   87,  814,
    968       839,  841,  815,  816,  831,  832,  834,   87,  840,  830,
    969       842,   87,   87,   87,  837,   87,   87,   87,   87,   87,
    970       857,  843,   87,   87,  845,  856,  861,   87,  858,   87,
    971 
    972        87,  846,  863,  864,   87,   87,   87,  855,   87,   87,
    973       859,  872,   87,  865,  862,  867,  860,  866,  870,   87,
    974        87,   87,  873,   87,  871,  874,  875,   87,   87,   87,
    975       876,  877,   87,   87,   87,  880,   87,  882,   87,  883,
    976        87,  878,   87,  881,  879,   87,   87,   87,   87,   87,
    977        87,  894,   87,  894,  887,  894,  894,  886,  868,  888,
    978       884,  885,  893,   87,   87,   87,  891,   87,   87,  889,
    979       890,  894,  892,   69,   69,   69,   69,   69,   69,   69,
    980        69,   69,   69,   69,   69,   69,   75,   75,   75,   75,
    981        75,   75,   75,   75,   75,   75,   75,   75,   75,   78,
    982 
    983        78,   78,   78,   78,   78,   78,   78,   78,   78,   78,
    984        78,   78,   86,  894,  854,   86,  894,   86,   86,   86,
    985        86,   86,  140,  853,  894,  851,  140,  140,  140,  140,
    986       140,  140,  199,  199,  199,  199,  199,  199,  199,  199,
    987       199,  199,  199,  199,  199,  204,  894,  850,  204,  894,
    988       204,  204,  204,  204,  204,  208,  849,  208,  208,  894,
    989       208,  208,  208,  208,  208,  208,  848,  208,  216,   87,
    990        87,  216,  216,  216,  216,  216,  216,  216,  216,   87,
    991       216,  239,  239,  239,  239,  239,  239,  239,  239,  239,
    992       239,  239,  239,  239,  253,  253,  894,  253,  829,  894,
    993 
    994       828,  253,  269,  826,  894,  269,  824,  269,  269,  269,
    995       269,  269,  273,  894,  273,  822,  894,  820,  273,  275,
    996       818,  275,   87,   87,   87,  275,  348,   87,  348,   87,
    997        87,   87,  348,  350,   87,  350,   87,   87,   87,  350,
    998       354,   87,  354,  894,  796,  794,  354,  356,  894,  356,
    999       894,  791,  789,  356,  358,  787,  358,   87,   87,   87,
    1000       358,  365,   87,  365,   87,   87,   87,  365,  367,  752,
    1001       367,  749,  748,  746,  367,  382,  205,  382,  384,  384,
    1002       742,  384,  384,  384,  741,  384,  253,  253,  673,  253,
    1003       269,   87,   87,  269,   87,  269,  269,  269,  269,  269,
    1004 
    1005       394,   87,  394,   87,   87,   87,  394,  396,   87,  396,
    1006        87,   87,   87,  396,  398,   87,  398,   87,   87,   87,
    1007       398,  273,  700,  273,  400,  699,  400,  697,  695,  693,
    1008       400,  275,  601,  275,   86,  688,  687,   86,  685,   86,
    1009        86,   86,   86,   86,  199,  199,  199,  199,  199,  199,
    1010       199,  199,  199,  199,  199,  199,  199,  470,  470,  470,
    1011       470,  470,  470,  470,  470,  470,  470,  470,  470,  470,
    1012       471,  683,  471,  681,  679,  677,  471,  473,  675,  473,
    1013       673,   87,   87,  473,  475,   87,  475,   87,   87,   87,
    1014       475,  348,   87,  348,  477,   87,  477,   87,   87,   87,
    1015 
    1016       477,  350,  620,  350,  480,  618,  480,  616,  614,  612,
    1017       480,  354,  610,  354,  482,  505,  482,  608,  608,  597,
    1018       482,  356,  596,  356,  484,  594,  484,  485,  485,  592,
    1019       484,  358,  590,  358,  486,  588,  486,  586,  584,  582,
    1020       486,  365,   87,  365,  488,   87,  488,   87,   87,   87,
    1021       488,  367,   87,  367,  494,   87,  494,   87,  494,  517,
    1022       494,  382,  515,  382,  513,  382,  511,  382,  384,  384,
    1023       509,  384,  384,  384,  507,  384,  506,  493,  506,  492,
    1024       489,  487,  506,  508,  361,  508,  361,  485,  483,  508,
    1025       510,  481,  510,  478,  476,  474,  510,  394,  472,  394,
    1026 
    1027       512,   87,  512,   87,   87,  402,  512,  396,  401,  396,
    1028       514,  399,  514,  397,  395,  270,  514,  398,  265,  398,
    1029       516,  264,  516,  391,  391,  252,  516,  400,  381,  400,
    1030        86,  381,  240,   86,  374,   86,   86,   86,   86,   86,
    1031       470,  470,  470,  470,  470,  470,  470,  470,  470,  470,
    1032       470,  470,  470,  581,  368,  581,  366,  364,  360,  581,
    1033       471,  359,  471,  583,  357,  583,  355,  351,  349,  583,
    1034       473,  205,  473,  585,  201,  585,   87,  277,  276,  585,
    1035       475,  274,  475,  587,  270,  587,  265,  268,  265,  587,
    1036       477,  263,  477,  589,  262,  589,  261,  240,  232,  589,
    1037 
    1038       480,   85,  480,  591,   85,  591,   87,  205,  203,  591,
    1039       482,   85,  482,  484,  122,  484,  117,   87,  894,  484,
    1040       593,   70,  593,   70,  894,  894,  593,  486,  894,  486,
    1041       595,  894,  595,  894,  894,  894,  595,  488,  894,  488,
    1042       494,  894,  494,  894,  494,  894,  494,  384,  894,  384,
    1043       894,  894,  894,  384,  609,  894,  609,  894,  894,  894,
    1044       609,  506,  894,  506,  611,  894,  611,  894,  894,  894,
    1045       611,  508,  894,  508,  613,  894,  613,  894,  894,  894,
    1046       613,  510,  894,  510,  615,  894,  615,  894,  894,  894,
    1047       615,  512,  894,  512,  617,  894,  617,  894,  894,  894,
    1048 
    1049       617,  514,  894,  514,  619,  894,  619,  894,  894,  894,
    1050       619,  516,  894,  516,   86,  894,  894,   86,  894,   86,
    1051        86,   86,   86,   86,  672,  672,  672,  672,  672,  672,
    1052       672,  672,  672,  672,  672,  672,  672,  674,  894,  674,
    1053       894,  894,  894,  674,  581,  894,  581,  676,  894,  676,
    1054       894,  894,  894,  676,  583,  894,  583,  678,  894,  678,
    1055       894,  894,  894,  678,  585,  894,  585,  680,  894,  680,
    1056       894,  894,  894,  680,  587,  894,  587,  682,  894,  682,
    1057       894,  894,  894,  682,  589,  894,  589,  684,  894,  684,
    1058       894,  894,  894,  684,  591,  894,  591,  686,  894,  686,
    1059 
    1060       894,  894,  894,  686,  593,  894,  593,   86,  894,   86,
    1061       894,  894,  894,   86,  595,  894,  595,  494,  894,  494,
    1062       894,  894,  894,  494,  694,  894,  694,  894,  894,  894,
    1063       694,  609,  894,  609,  696,  894,  696,  894,  894,  894,
    1064       696,  611,  894,  611,  698,  894,  698,  894,  894,  894,
    1065       698,  613,  894,  613,  140,  894,  140,  894,  894,  894,
    1066       140,  615,  894,  615,  701,  894,  701,  617,  894,  617,
    1067        86,  894,  894,   86,  894,   86,   86,   86,   86,   86,
    1068       619,  894,  619,  672,  672,  672,  672,  672,  672,  672,
    1069       672,  672,  672,  672,  672,  672,  740,  894,  740,  894,
    1070 
    1071       894,  894,  740,  674,  894,  674,  204,  894,  204,  894,
    1072       894,  894,  204,  676,  894,  676,  743,  894,  743,  678,
    1073       894,  678,  204,  894,  894,  204,  894,  204,  204,  204,
    1074       204,  204,  680,  894,  680,  744,  894,  744,  682,  894,
    1075       682,  684,  894,  684,  745,  894,  745,  686,  894,  686,
    1076        86,  894,   86,  747,  894,  747,  894,  894,  894,  747,
    1077       694,  894,  694,  269,  894,  269,  894,  894,  894,  269,
    1078       696,  894,  696,  750,  894,  750,  698,  894,  698,  140,
    1079       894,  140,  751,  894,  751,  894,  894,  894,  751,   86,
    1080       894,  894,   86,  894,   86,   86,   86,   86,   86,  785,
    1081 
    1082       894,  785,  740,  894,  740,  204,  894,  204,  786,  894,
    1083       786,  894,  894,  894,  786,  788,  894,  788,  894,  894,
    1084       894,  788,  790,  894,  790,  894,  894,  894,  790,  792,
    1085       894,  792,  793,  894,  793,  894,  894,  894,  793,  795,
    1086       894,  795,  894,  894,  894,  795,  817,  894,  817,  894,
    1087       894,  894,  817,  819,  894,  819,  894,  894,  894,  819,
    1088       821,  894,  821,  894,  894,  894,  821,  823,  894,  823,
    1089       894,  894,  894,  823,  825,  894,  825,  894,  894,  894,
    1090       825,  827,  894,  827,  894,  894,  894,  827,  619,  894,
    1091       619,  894,  894,  894,  619,  847,  894,  847,  894,  894,
    1092 
    1093       894,  847,  680,  894,  680,  894,  894,  894,  680,  684,
    1094       894,  684,  894,  894,  894,  684,   86,  894,   86,  894,
    1095       894,  894,   86,  852,  894,  852,  894,  894,  894,  852,
    1096       140,  894,  140,  894,  894,  894,  140,  204,  894,  204,
    1097       894,  894,  894,  204,   11,  894,  894,  894,  894,  894,
    1098       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1099       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1100       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1101       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1102       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1103 
    1104       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1105       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1106       894,  894,  894,  894,  894,  894,  894,  894,  894,  894
     801       72,   72,   72,   72,   72,   72,   72,   72,   72,   73,
     802       73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
     803       73,   73,   73,   73,   73,   72,   74,   72,   72,   73,
     804       75,   73,   73,   73,   73,   73,   73,   73,   73,   73,
     805       73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
     806       73,   73,   73,   73,   73,   72,   72,   72,   72,   77,
     807       77,   80,   80,  124,  125,   91,  142,   80,   80,   88,
     808       77,   77,   81,   82,   83,   83,   83,   81,   83,   82,
     809
     810       84,   84,   84,   83,   92,   94,   88,  143,  147,   99,
     811       96,  100,  100,  100,  100,  100,  100,  255,  904,   95,
     812      101,   86,   97,   98,   86,  102,  162,  119,  144,   78,
     813       78,   78,   78,  145,  148,  103,  104,   88,  105,  105,
     814      105,  105,  106,  106,  120,   88,  121,  122,  149,  266,
     815      150,  267,  257,  263,  185,  107,  198,  648,  160,  108,
     816      161,  151,  152,  153,   88,  109,  110,  154,  155,  163,
     817      156,  111,   88,  157,  158,  146,  164,  107,   88,   88,
     818       88,  159,  165,  112,  209,   88,   88,   88,  197,   88,
     819       88,  109,  196,   88,  110,  104,  253,  113,  113,  113,
     820
     821      113,  113,  113,   88,  170,  178,  171,  199,  195,   88,
     822      210,  181,  166,  233,  107,  172,  167,  182,  114,  179,
     823      254,  168,   88,  261,  115,  169,  180,  173,   88,  144,
     824      116,   88,  251,  326,  145,  174,  107,  175,  252,  234,
     825      176,  144,  117,  266,  177,  267,  145,  262,  183,   88,
     826      115,  126,   88,  184,  252,  127,  128,   88,  129,  193,
     827      130,  131,  259,  132,  252,  133,   88,  283,  260,  186,
     828      187,  260,  251,   88,  134,  135,  136,   88,  190,  188,
     829      252,  266,  189,  267,  274,   88,  191,  268,  146,  259,
     830      337,  203,  204,  192,  260,  137,  203,  260,  138,  266,
     831
     832      904,  267,  194,  200,   82,   83,   83,   83,  200,   88,
     833      275,  201,  205,  205,  205,  205,  205,  205,   81,   82,
     834       83,   83,   83,   81,   88,  139,  140,  212,  213,  266,
     835      904,  267,  212,  285,  214,  258,  266,   88,  267,  214,
     836       83,   82,   83,   83,   83,   83,  303,   88,  215,  215,
     837      215,  215,   83,   82,   84,   84,   84,   83,  904,  214,
     838      244,  244,  244,  244,  244,  244,  245,  245,  245,  245,
     839      269,  266,  266,  267,  267,  216,  268,   88,  214,  266,
     840      270,  267,   88,  214,  214,   88,   88,  214,  214,  266,
     841      266,  267,  267,  286,  904,  214,   88,  317,  214,  246,
     842
     843      214,  217,  214,  284,  218,  220,   88,   88,  288,  221,
     844      222,  281,   88,   88,  223,  224,   88,  225,  282,  226,
     845       88,  327,  904,  301,  287,  289,   88,   88,  227,  228,
     846      229,  104,  306,  106,  106,  106,  106,  106,  106,  311,
     847       88,   88,  302,   88,   88,  307,   88,  304,  305,  230,
     848      107,  248,  231,  248,  309,   88,  249,  249,  249,  249,
     849      249,  249,  310,  308,  313,   88,  247,  312,   88,   88,
     850      314,   88,  107,   88,   88,   88,   88,  316,   88,   88,
     851      232,  236,  236,  236,  236,  236,  236,  319,  315,  250,
     852      318,  320,  325,  323,   88,  321,  322,  237,  238,  239,
     853
     854      324,  240,  239,  328,   88,  329,   88,   88,  144,  365,
     855       88,  366,   88,   88,  241,  330,  331,  333,  335,  239,
     856      238,  239,   88,  341,  240,  332,  239,  290,  291,  292,
     857      338,  293,  294,  336,  334,  295,   88,  296,   88,  351,
     858       88,  339,  297,  298,  299,   88,  300,   88,  385,  212,
     859      213,  343,   88,  347,  212,  342,  203,  204,  345,  344,
     860      346,  203,  365,  340,  366,  352,  395,  348,  200,   82,
     861       83,   83,   83,  200,  385,   88,  201,  205,  205,  205,
     862      205,  205,  205,  203,  204,  365,  904,  366,  203,  349,
     863      204,  365,  395,  366,  349,  414,  350,  357,  357,  357,
     864
     865      357,  365,  366,  366,  205,  205,  205,  205,  205,  205,
     866      205,  205,  205,  205,  205,  205,  365,  366,  366,  367,
     867      365,  382,  366,  365,  368,  366,  365,  374,  366,  365,
     868      358,  366,  365,   88,  366,  374,  374,  375,  266,  375,
     869      267,   88,  376,  376,  376,  376,  376,  376,  397,  378,
     870      374,  378,   88,  266,  378,  267,  420,  411,  374,  380,
     871      380,  380,  380,  380,  380,  104,  550,  245,  245,  245,
     872      245,  378,   88,  378,  398,  377,   88,  413,  378,  106,
     873      106,  106,  106,  106,  106,  249,  249,  249,  249,  249,
     874      249,   88,  381,   88,  409,   88,  107,  248,   88,  248,
     875
     876      246,   88,  249,  249,  249,  249,  249,  249,  408,  410,
     877      412,   88,  258,  423,   88,   88,  415,   88,  107,  383,
     878      383,  383,  383,  383,  383,  388,  427,  422,  106,  106,
     879      106,  106,  106,  106,  416,  237,   88,  239,  461,  240,
     880      239,  113,  113,  113,  113,  113,  113,   88,  390,  428,
     881      391,   88,  384,   88,  392,   88,   88,  239,  426,  239,
     882      393,  258,  240,   88,  239,  421,   88,  424,  425,   88,
     883       88,  417,  394,   88,  263,  432,  391,  418,  419,   88,
     884      392,  430,  429,   88,  431,   88,   88,   88,  433,  435,
     885      434,  436,  439,   88,   88,   88,   88,   88,  440,   88,
     886
     887      441,   88,  444,   88,  443,  442,  437,  438,  446,   88,
     888       88,   88,   88,  445,  448,  449,  447,  450,   88,   88,
     889       88,   88,  452,   88,  457,   88,   88,   88,   88,  453,
     890      455,  454,   88,   88,  451,  456,   88,   88,  459,   88,
     891       88,  464,  458,   88,  144,  463,   88,  462,  460,   88,
     892      469,   88,  470,   88,   88,  465,  474,   88,  468,  466,
     893      502,  467,  472,  204,  471,  473,  349,  204,  475,  202,
     894      503,  349,  476,  350,  214,  214,  214,  214,  357,  357,
     895      357,  357,  365,  365,  366,  366,  502,   88,   88,  376,
     896      376,  376,  376,  376,  376,  375,  502,  375,  525,  510,
     897
     898      376,  376,  376,  376,  376,  376,  504,  486,  497,  497,
     899      497,  497,  497,  497,  236,  236,  236,  236,  236,  236,
     900       88,   88,  502,  511,  237,   88,  239,   88,  240,  239,
     901      245,  245,  245,  245,  106,  106,  505,  526,  530,  528,
     902      527,  498,  506,  506,   88,   88,  239,  379,  239,   88,
     903       88,  240,   88,  239,  380,  380,  380,  380,  380,  380,
     904      388,  505,  534,  382,   88,  537,  532,  536,  506,  506,
     905      237,  238,  239,  529,  240,  239,  383,  383,  383,  383,
     906      383,  383,   88,  390,   88,  391,  904,  381,  545,  392,
     907      904,  904,  239,  238,  239,  393,  507,  240,  507,  239,
     908
     909      535,  508,  508,  508,  508,  508,  508,  394,   88,  384,
     910       88,  391,   88,   88,  390,  392,  391,  531,   88,  533,
     911      392,   88,   88,   88,   88,   88,  512,  542,  538,  539,
     912       88,   88,  547,   88,  509,  540,  541,   88,  394,   88,
     913      543,   88,  391,  548,  546,  549,  392,  544,   88,  551,
     914       88,   88,  552,   88,  554,  553,  556,   88,   88,   88,
     915      558,   88,  555,  557,   88,   88,   88,   88,  559,   88,
     916       88,   88,   88,   88,  562,  566,   88,  560,   88,  564,
     917      561,  570,   88,  563,  567,  565,   88,   88,   88,   88,
     918       88,  571,  568,  569,  578,  574,  572,  575,  573,  577,
     919
     920      576,   88,   88,   88,   88,   88,   88,  204,  579,   88,
     921      582,   88,  581,  589,  580,  587,  585,  502,  611,   88,
     922      583,  584,  588,   88,  631,  586,  214,  214,  214,  214,
     923      497,  497,  497,  497,  497,  497,  380,  380,  380,  380,
     924      380,  380,   88,  502,  611,   88,  237,   88,  239,   88,
     925      240,  239,  383,  383,  383,  383,  383,  383,   88,  630,
     926      632,  502,  634,  498,   88,   88,  502,  633,  239,  499,
     927      239,  503,  607,  240,  607,  239,  610,  608,  608,  608,
     928      608,  608,  608,   88,  642,  500,  635,  502,  637,   88,
     929       88,   88,  502,  508,  508,  508,  508,  508,  508,  507,
     930
     931       88,  507,  636,  639,  508,  508,  508,  508,  508,  508,
     932      609,  612,  612,  612,  612,  612,  612,   88,   88,   88,
     933       88,   88,   88,   88,  904,   88,   88,  613,  638,  614,
     934      644,  615,  614,  646,  641,   88,  647,   88,  640,   88,
     935      645,  643,   88,  651,  616,   88,  649,  650,  652,  614,
     936      653,  614,  654,   88,  615,   88,  614,   88,   88,  656,
     937       88,   88,  655,   88,   88,   88,   88,   88,   88,  659,
     938      657,   88,  658,  660,   88,  662,  665,  666,  661,   88,
     939      663,  664,   88,  667,   88,   88,   88,   88,   88,  668,
     940       88,  676,  669,  671,  672,  673,  677,   88,   88,  670,
     941
     942       88,   88,  675,   88,   88,  904,   88,  777,  674,  712,
     943      678,   88,  701,  701,  680,  679,  497,  497,  497,  497,
     944      497,  497,  713,  717,  716,  681,  608,  608,  608,  608,
     945      608,  608,  607,  701,  607,  701,   88,  608,  608,  608,
     946      608,  608,  608,  612,  612,  612,  612,  612,  612,  606,
     947      699,  699,  699,  699,  699,  699,  701,  702,   88,  702,
     948       88,   88,  702,   88,   88,  714,  613,   88,  614,  715,
     949      615,  614,  720,  731,  719,   88,  616,   88,  722,  702,
     950      721,  702,   88,  700,  718,   88,  702,   88,  614,   88,
     951      614,   88,   88,  615,   88,  614,   88,  725,  723,  724,
     952
     953       88,   88,   88,  729,   88,   88,  727,  732,   88,  726,
     954       88,  730,   88,  728,  734,   88,  733,  737,   88,   88,
     955      735,   88,   88,  879,  740,   88,  736,   88,   88,   88,
     956      744,   88,  745,  738,  739,   88,  746,  748,  741,  743,
     957       88,  747,   88,   88,  749,  764,  742,  699,  699,  699,
     958      699,  699,  699,  612,  612,  612,  612,  612,  612,   88,
     959       88,  763,  768,  613,   88,  614,  766,  615,  614,  765,
     960       88,   88,  783,   88,  769,  767,  770,   88,  771,   88,
     961      700,   88,   88,  772,  780,  614,  703,  614,  774,   88,
     962      615,   88,  614,   88,  773,   88,  775,   88,  778,   88,
     963
     964      779,   88,  781,  776,   88,   88,   88,  784,   88,   88,
     965       88,  791,   88,   88,  782,  787,   88,  785,   88,  904,
     966       88,  793,   88,  809,   88,  794,  786,  788,  790,   88,
     967       88,   88,  789,  792,  699,  699,  699,  699,  699,  699,
     968      807,  808,   88,   88,  810,  812,  815,  813,   88,  817,
     969       88,   88,  811,  818,  819,   88,   88,  814,   88,  821,
     970       88,  816,  820,  822,   88,   88,   88,  756,   88,   88,
     971      848,   88,   88,  823,   88,  843,   88,   88,   88,  845,
     972       88,  846,   88,   88,  904,  849,   88,  824,  825,  826,
     973      841,   88,  842,  844,  851,  840,   88,   88,  847,   88,
     974
     975      852,   88,  854,   88,   88,  850,   88,   88,  853,   88,
     976      867,   88,  855,  866,   88,   88,   88,  871,  868,  856,
     977       88,   88,   88,  873,  874,  865,  904,   88,  876,  869,
     978       88,  875,  872,   88,   88,  870,  877,  882,  881,  880,
     979       88,   88,   88,   88,   88,  885,  884,  886,   88,   88,
     980      883,  887,   88,   88,   88,  890,   88,  892,   88,   88,
     981       88,  893,   88,  888,  889,   88,  891,   88,   88,  897,
     982       88,   88,   88,  904,  878,  894,   88,  896,  898,   88,
     983      895,   88,  903,   88,   88,  904,  901,  904,  864,  899,
     984      904,  900,  863,  902,   70,   70,   70,   70,   70,   70,
     985
     986       70,   70,   70,   70,   70,   70,   70,   76,   76,   76,
     987       76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
     988       79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
     989       79,   79,   79,   87,  904,  861,   87,  904,   87,   87,
     990       87,   87,   87,  141,  860,  904,  859,  141,  141,  141,
     991      141,  141,  141,  202,  202,  202,  202,  202,  202,  202,
     992      202,  202,  202,  202,  202,  202,  207,  904,  858,  207,
     993       88,  207,  207,  207,  207,  207,  211,   88,  211,  211,
     994       88,  211,  211,  211,  211,  211,  211,  904,  211,  219,
     995      839,  904,  219,  219,  219,  219,  219,  219,  219,  219,
     996
     997      838,  219,  242,  242,  242,  242,  242,  242,  242,  242,
     998      242,  242,  242,  242,  242,  256,  256,  836,  256,  904,
     999      834,  904,  256,  272,  832,  904,  272,  830,  272,  272,
     1000      272,  272,  272,  276,  828,  276,   88,   88,   88,  276,
     1001      278,   88,  278,   88,   88,   88,  278,  353,   88,  353,
     1002       88,   88,   88,  353,  355,   88,  355,  904,  806,  804,
     1003      355,  359,  904,  359,  904,  801,  799,  359,  361,  797,
     1004      361,   88,   88,   88,  361,  363,   88,  363,   88,   88,
     1005       88,  363,  370,  762,  370,  759,  758,  756,  370,  372,
     1006      208,  372,  752,  751,  683,  372,  387,   88,  387,  389,
     1007
     1008      389,   88,  389,  389,  389,   88,  389,  256,  256,   88,
     1009      256,  272,   88,   88,  272,   88,  272,  272,  272,  272,
     1010      272,  399,   88,  399,   88,   88,   88,  399,  401,   88,
     1011      401,   88,   88,   88,  401,  403,   88,  403,  710,  709,
     1012      707,  403,  276,  705,  276,  405,  703,  405,  610,  698,
     1013      697,  405,  278,  695,  278,   87,  693,  691,   87,  689,
     1014       87,   87,   87,   87,   87,  202,  202,  202,  202,  202,
     1015      202,  202,  202,  202,  202,  202,  202,  202,  477,  477,
     1016      477,  477,  477,  477,  477,  477,  477,  477,  477,  477,
     1017      477,  478,  687,  478,  685,  683,   88,  478,  480,   88,
     1018
     1019      480,   88,   88,   88,  480,  482,   88,  482,   88,   88,
     1020       88,  482,  353,   88,  353,  484,   88,  484,   88,  629,
     1021      627,  484,  355,  625,  355,  487,  623,  487,  621,  619,
     1022      512,  487,  359,  617,  359,  489,  617,  489,  606,  605,
     1023      603,  489,  361,  492,  361,  491,  492,  491,  601,  599,
     1024      597,  491,  363,  595,  363,  493,  593,  493,  591,   88,
     1025       88,  493,  370,   88,  370,  495,   88,  495,   88,   88,
     1026       88,  495,  372,   88,  372,  501,  524,  501,  522,  501,
     1027      520,  501,  387,  518,  387,  516,  387,  514,  387,  389,
     1028      389,  500,  389,  389,  389,  499,  389,  513,  496,  513,
     1029
     1030      494,  366,  366,  513,  515,  492,  515,  490,  488,  485,
     1031      515,  517,  483,  517,  481,  479,   88,  517,  399,   88,
     1032      399,  519,   88,  519,  407,  406,  404,  519,  401,  402,
     1033      401,  521,  400,  521,  273,  268,  267,  521,  403,  396,
     1034      403,  523,  396,  523,  255,  386,  386,  523,  405,  243,
     1035      405,   87,  379,  373,   87,  371,   87,   87,   87,   87,
     1036       87,  477,  477,  477,  477,  477,  477,  477,  477,  477,
     1037      477,  477,  477,  477,  590,  369,  590,  365,  364,  362,
     1038      590,  478,  360,  478,  592,  356,  592,  354,  208,  204,
     1039      592,  480,   88,  480,  594,  280,  594,  279,  277,  273,
     1040
     1041      594,  482,  268,  482,  596,  271,  596,  268,  266,  265,
     1042      596,  484,  264,  484,  598,  243,  598,  235,   86,   86,
     1043      598,  487,   88,  487,  600,  208,  600,  206,   86,  123,
     1044      600,  489,  118,  489,  491,   88,  491,  904,   71,   71,
     1045      491,  602,  904,  602,  904,  904,  904,  602,  493,  904,
     1046      493,  604,  904,  604,  904,  904,  904,  604,  495,  904,
     1047      495,  501,  904,  501,  904,  501,  904,  501,  389,  904,
     1048      389,  904,  904,  904,  389,  618,  904,  618,  904,  904,
     1049      904,  618,  513,  904,  513,  620,  904,  620,  904,  904,
     1050      904,  620,  515,  904,  515,  622,  904,  622,  904,  904,
     1051
     1052      904,  622,  517,  904,  517,  624,  904,  624,  904,  904,
     1053      904,  624,  519,  904,  519,  626,  904,  626,  904,  904,
     1054      904,  626,  521,  904,  521,  628,  904,  628,  904,  904,
     1055      904,  628,  523,  904,  523,   87,  904,  904,   87,  904,
     1056       87,   87,   87,   87,   87,  682,  682,  682,  682,  682,
     1057      682,  682,  682,  682,  682,  682,  682,  682,  684,  904,
     1058      684,  904,  904,  904,  684,  590,  904,  590,  686,  904,
     1059      686,  904,  904,  904,  686,  592,  904,  592,  688,  904,
     1060      688,  904,  904,  904,  688,  594,  904,  594,  690,  904,
     1061      690,  904,  904,  904,  690,  596,  904,  596,  692,  904,
     1062
     1063      692,  904,  904,  904,  692,  598,  904,  598,  694,  904,
     1064      694,  904,  904,  904,  694,  600,  904,  600,  696,  904,
     1065      696,  904,  904,  904,  696,  602,  904,  602,   87,  904,
     1066       87,  904,  904,  904,   87,  604,  904,  604,  501,  904,
     1067      501,  904,  904,  904,  501,  704,  904,  704,  904,  904,
     1068      904,  704,  618,  904,  618,  706,  904,  706,  904,  904,
     1069      904,  706,  620,  904,  620,  708,  904,  708,  904,  904,
     1070      904,  708,  622,  904,  622,  141,  904,  141,  904,  904,
     1071      904,  141,  624,  904,  624,  711,  904,  711,  626,  904,
     1072      626,   87,  904,  904,   87,  904,   87,   87,   87,   87,
     1073
     1074       87,  628,  904,  628,  682,  682,  682,  682,  682,  682,
     1075      682,  682,  682,  682,  682,  682,  682,  750,  904,  750,
     1076      904,  904,  904,  750,  684,  904,  684,  207,  904,  207,
     1077      904,  904,  904,  207,  686,  904,  686,  753,  904,  753,
     1078      688,  904,  688,  207,  904,  904,  207,  904,  207,  207,
     1079      207,  207,  207,  690,  904,  690,  754,  904,  754,  692,
     1080      904,  692,  694,  904,  694,  755,  904,  755,  696,  904,
     1081      696,   87,  904,   87,  757,  904,  757,  904,  904,  904,
     1082      757,  704,  904,  704,  272,  904,  272,  904,  904,  904,
     1083      272,  706,  904,  706,  760,  904,  760,  708,  904,  708,
     1084
     1085      141,  904,  141,  761,  904,  761,  904,  904,  904,  761,
     1086       87,  904,  904,   87,  904,   87,   87,   87,   87,   87,
     1087      795,  904,  795,  750,  904,  750,  207,  904,  207,  796,
     1088      904,  796,  904,  904,  904,  796,  798,  904,  798,  904,
     1089      904,  904,  798,  800,  904,  800,  904,  904,  904,  800,
     1090      802,  904,  802,  803,  904,  803,  904,  904,  904,  803,
     1091      805,  904,  805,  904,  904,  904,  805,  827,  904,  827,
     1092      904,  904,  904,  827,  829,  904,  829,  904,  904,  904,
     1093      829,  831,  904,  831,  904,  904,  904,  831,  833,  904,
     1094      833,  904,  904,  904,  833,  835,  904,  835,  904,  904,
     1095
     1096      904,  835,  837,  904,  837,  904,  904,  904,  837,  628,
     1097      904,  628,  904,  904,  904,  628,  857,  904,  857,  904,
     1098      904,  904,  857,  690,  904,  690,  904,  904,  904,  690,
     1099      694,  904,  694,  904,  904,  904,  694,   87,  904,   87,
     1100      904,  904,  904,   87,  862,  904,  862,  904,  904,  904,
     1101      862,  141,  904,  141,  904,  904,  904,  141,  207,  904,
     1102      207,  904,  904,  904,  207,   11,  904,  904,  904,  904,
     1103      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1104      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1105      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1106
     1107      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1108      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1109      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1110      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1111      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1112      904
    11071113    } ;
    11081114
    1109 static yyconst flex_int16_t yy_chk[2931] =
     1115static yyconst flex_int16_t yy_chk[2952] =
    11101116    {   0,
    11111117        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     
    11281134        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
    11291135        5,    5,    5,    5,    5,    5,    5,    5,    5,    7,
    1130         8,    9,   10,   37,   37,   20,   39,    9,   10,  893,
     1136        8,    9,   10,   37,   37,   20,   39,    9,   10,  903,
    11311137        7,    8,   13,   13,   13,   13,   13,   13,   15,   15,
    11321138
    11331139       15,   15,   15,   15,   20,   25,   48,   39,   42,   28,
    1134        27,   28,   28,   28,   28,   28,   28,  109,  115,   25,
     1140       27,   28,   28,   28,   28,   28,   28,  110,  116,   25,
    11351141       29,   25,   27,   27,   27,   29,   48,   35,   40,    7,
    11361142        8,    9,   10,   40,   42,   29,   30,   47,   30,   30,
    1137        30,   30,   30,   30,   35,   57,   35,   35,   44,  126,
    1138        44,  126,  109,  115,   57,   30,   64,   56,   47,   30,
     1143       30,   30,   30,   30,   35,   57,   35,   35,   44,  127,
     1144       44,  127,  110,  116,   57,   30,   65,  544,   47,   30,
    11391145       47,   45,   45,   45,   49,   30,   30,   45,   45,   49,
    1140        45,   30,   40,   45,   45,   40,   49,   30,   45,   56,
    1141        62,   45,   49,   30,   73,  892,  127,   53,  127,   51,
    1142        61,   30,   62,   55,   30,   31,  108,   31,   31,   31,
    1143 
    1144        31,   31,   31,   50,   51,   53,   51,   64,   61,   54,
    1145        73,   55,   50,   87,   31,   51,   50,   55,   31,   54,
    1146       108,   50,   52,  114,   31,   50,   54,   52,  175,  129,
    1147        31,  129,  107,  154,  151,   52,   31,   52,  107,   87,
    1148        52,   60,   31,  132,   52,  132,   60,  114,  175,  154,
    1149        31,   38,  151,  387,  111,   38,   38,   58,   38,   60,
    1150        38,   38,  113,   38,  107,   38,   59,  130,  113,   58,
    1151        58,  116,  111,  164,   38,   38,   38,  387,   59,   58,
    1152       111,  130,   58,  130,  142,   60,   59,  131,   60,  116,
    1153       164,   68,   68,   59,  113,   38,   68,  116,   38,  131,
    1154 
    1155       110,  131,   60,   67,   67,   67,   67,   67,   67,  884,
    1156       142,   67,   68,   68,   68,   68,   68,   68,   80,   80,
    1157        80,   80,   80,   80,  153,   38,   38,   77,   77,  134,
    1158       110,  134,   77,  153,   77,  110,  135,  135,  135,   77,
    1159        82,   82,   82,   82,   82,   82,  883,  243,   77,   77,
    1160        77,   77,   83,   83,   83,   83,   83,   83,  110,   77,
    1161       103,  103,  103,  103,  103,  103,  104,  104,  104,  104,
    1162       133,  133,  137,  133,  137,   77,  145,  139,   77,  139,
    1163       157,  145,  243,   77,   77,  152,  156,   77,   77,  155,
    1164       166,  150,  157,  880,  104,   77,  159,  168,   77,  104,
    1165 
    1166        77,   77,   77,  152,   77,   85,  150,  155,  156,   85,
    1167        85,  166,  159,  150,   85,   85,  161,   85,  160,   85,
    1168       145,  162,  104,  167,  168,  161,  169,  163,   85,   85,
    1169        85,  105,  163,  105,  105,  105,  105,  105,  105,  879,
    1170       160,  171,  162,  162,  165,  163,  167,  169,  173,   85,
    1171       105,  106,   85,  106,  165,  172,  106,  106,  106,  106,
    1172       106,  106,  180,  171,  170,  173,  105,  176,  177,  170,
    1173       172,  181,  105,  174,  184,  187,  181,  182,  179,  180,
    1174        85,   99,   99,   99,   99,   99,   99,  170,  187,  106,
    1175       177,  174,  184,  179,  176,  183,  190,   99,   99,   99,
    1176 
    1177       179,   99,   99,  189,  182,  186,  183,  191,  189,  218,
    1178       186,  218,  185,  188,   99,  190,  183,  183,  284,   99,
    1179        99,   99,  158,  185,   99,  186,   99,  158,  158,  158,
    1180       189,  158,  158,  188,  192,  158,  194,  158,  284,  219,
    1181       185,  219,  158,  158,  158,  193,  158,  192,  220,  194,
    1182       220,  191,  198,  198,  191,  192,  205,  198,  193,  877,
    1183       193,  197,  197,  197,  197,  197,  197,  200,  200,  197,
    1184       248,  221,  200,  198,  198,  198,  198,  198,  198,  202,
    1185       202,  223,  205,  223,  202,  221,  202,  221,  200,  200,
    1186       200,  200,  200,  200,  209,  209,  248,  876,  222,  209,
    1187 
    1188       202,  202,  202,  202,  202,  202,  212,  212,  212,  212,
    1189       222,  286,  222,  224,  224,  225,  224,  225,  226,  226,
    1190       226,  228,  229,  228,  229,  234,  234,  235,  236,  235,
    1191       869,  286,  235,  235,  235,  235,  235,  235,  237,  212,
    1192       237,  282,  242,  237,  242,  242,  242,  242,  234,  256,
    1193       270,  236,  241,  241,  241,  241,  241,  241,  282,  266,
    1194       237,  266,  237,  296,  267,  235,  267,  237,  281,  244,
    1195       244,  244,  244,  244,  244,  256,  270,  242,  245,  245,
    1196       245,  245,  245,  245,  281,  241,  244,  247,  278,  247,
    1197       296,  295,  247,  247,  247,  247,  247,  247,  279,  280,
    1198 
    1199       283,  278,  244,  288,  295,  283,  289,  868,  244,  246,
    1200       246,  246,  246,  246,  246,  253,  279,  280,  255,  255,
    1201       255,  255,  255,  255,  289,  246,  288,  246,  291,  246,
    1202       246,  260,  260,  260,  260,  260,  260,  290,  253,  292,
    1203       253,  285,  246,  291,  253,  867,  285,  246,  294,  246,
    1204       253,  255,  246,  287,  246,  292,  292,  294,  297,  299,
    1205       293,  303,  253,  290,  260,  293,  253,  300,  287,  301,
    1206       253,  304,  300,  302,  287,  287,  297,  299,  301,  305,
    1207       302,  303,  306,  307,  308,  309,  310,  306,  307,  304,
    1208       308,  311,  312,  313,  314,  310,  318,  311,  315,  319,
    1209 
    1210       305,  305,  313,  315,  309,  316,  317,  320,  312,  314,
    1211       316,  317,  322,  324,  323,  318,  326,  319,  325,  327,
    1212       320,  328,  329,  322,  330,  331,  332,  334,  317,  323,
    1213       333,  325,  324,  330,  337,  335,  338,  339,  326,  329,
    1214       340,  328,  327,  337,  343,  334,  341,  331,  335,  332,
    1215       639,  342,  333,  340,  341,  339,  342,  344,  344,  343,
    1216       345,  362,  344,  362,  344,  403,  345,  352,  352,  352,
    1217       352,  353,  353,  353,  353,  363,  403,  363,  639,  408,
    1218       338,  370,  370,  370,  370,  370,  370,  372,  382,  372,
    1219       408,  410,  372,  372,  372,  372,  372,  372,  382,  404,
    1220 
    1221       352,  371,  371,  371,  371,  371,  371,  374,  374,  374,
    1222       374,  374,  374,  410,  382,  404,  405,  371,  406,  371,
    1223       412,  371,  371,  377,  377,  377,  377,  377,  377,  385,
    1224       425,  405,  383,  412,  371,  385,  389,  406,  414,  371,
    1225       374,  371,  383,  413,  371,  425,  371,  375,  375,  375,
    1226       375,  375,  375,  384,  389,  417,  377,  407,  383,  413,
    1227       414,  385,  389,  375,  375,  375,  407,  375,  375,  378,
    1228       378,  378,  378,  378,  378,  421,  384,  417,  384,  866,
    1229       375,  421,  384,  865,  388,  375,  375,  375,  384,  386,
    1230       375,  386,  375,  415,  386,  386,  386,  386,  386,  386,
    1231 
    1232       384,  409,  378,  411,  384,  416,  415,  388,  384,  388,
    1233       409,  418,  411,  388,  423,  419,  422,  424,  420,  388,
    1234       419,  416,  416,  431,  427,  423,  432,  386,  433,  418,
    1235       429,  388,  434,  420,  441,  388,  424,  422,  427,  388,
    1236       420,  433,  429,  435,  431,  436,  439,  437,  432,  435,
    1237       442,  443,  444,  445,  441,  434,  437,  446,  447,  449,
    1238       436,  439,  451,  453,  452,  456,  443,  447,  445,  454,
    1239       455,  457,  442,  452,  444,  458,  449,  446,  459,  460,
    1240       457,  461,  462,  463,  453,  451,  460,  456,  461,  454,
    1241       455,  459,  464,  458,  465,  466,  468,  470,  528,  469,
    1242 
    1243       464,  528,  861,  470,  519,  463,  466,  462,  469,  524,
    1244       464,  465,  479,  479,  479,  479,  518,  519,  468,  490,
    1245       490,  490,  490,  490,  490,  492,  492,  492,  492,  492,
    1246       492,  524,  544,  518,  522,  490,  521,  490,  544,  490,
    1247       490,  493,  493,  493,  493,  493,  493,  497,  526,  498,
    1248       494,  521,  490,  526,  522,  496,  532,  490,  492,  490,
    1249       494,  495,  490,  495,  490,  496,  495,  495,  495,  495,
    1250       495,  495,  567,  497,  493,  498,  494,  532,  523,  525,
    1251       567,  496,  500,  500,  500,  500,  500,  500,  502,  529,
    1252       502,  523,  525,  502,  502,  502,  502,  502,  502,  495,
    1253 
    1254       501,  501,  501,  501,  501,  501,  527,  530,  531,  529,
    1255       533,  857,  536,  535,  539,  537,  501,  527,  501,  533,
    1256       501,  501,  530,  534,  535,  536,  538,  531,  534,  540,
    1257       541,  547,  542,  501,  548,  538,  539,  542,  501,  541,
    1258       501,  545,  549,  501,  537,  501,  540,  550,  547,  548,
    1259       545,  552,  553,  554,  558,  555,  550,  549,  557,  558,
    1260       552,  563,  560,  561,  564,  554,  568,  565,  569,  553,
    1261       555,  560,  561,  557,  570,  569,  568,  564,  571,  572,
    1262       574,  575,  577,  563,  565,  572,  713,  578,  622,  574,
    1263       571,  575,  713,  604,  604,  622,  570,  625,  854,  577,
    1264 
    1265       578,  597,  597,  597,  597,  597,  597,  598,  598,  598,
    1266       598,  598,  598,  600,  625,  600,  604,  624,  600,  600,
    1267       600,  600,  600,  600,  603,  603,  603,  603,  603,  603,
    1268       624,  605,  814,  629,  597,  599,  599,  599,  599,  599,
    1269       599,  606,  621,  606,  626,  627,  606,  621,  814,  623,
    1270       629,  599,  627,  599,  605,  599,  599,  603,  623,  630,
    1271       621,  628,  630,  606,  631,  606,  632,  626,  599,  628,
    1272       606,  633,  634,  599,  635,  599,  636,  631,  599,  637,
    1273       599,  640,  637,  638,  641,  643,  633,  644,  632,  647,
    1274       642,  635,  645,  648,  634,  705,  640,  649,  636,  642,
    1275 
    1276       638,  645,  653,  643,  641,  654,  649,  656,  659,  644,
    1277       667,  660,  647,  668,  671,  648,  670,  659,  660,  667,
    1278       703,  705,  653,  668,  656,  670,  702,  853,  708,  671,
    1279       703,  852,  654,  689,  689,  689,  689,  689,  689,  693,
    1280       693,  693,  693,  693,  693,  706,  711,  702,  708,  689,
    1281       707,  689,  706,  689,  689,  707,  709,  710,  715,  709,
    1282       710,  714,  716,  717,  711,  716,  689,  715,  718,  721,
    1283       720,  689,  693,  689,  714,  723,  689,  719,  689,  720,
    1284       719,  724,  722,  725,  717,  722,  726,  727,  723,  724,
    1285       735,  728,  731,  725,  734,  721,  736,  718,  738,  726,
    1286 
    1287       728,  760,  739,  761,  757,  762,  738,  764,  727,  758,
    1288       731,  739,  735,  761,  734,  731,  760,  736,  746,  746,
    1289       746,  746,  746,  746,  757,  759,  758,  763,  762,  765,
    1290       759,  767,  765,  764,  766,  769,  771,  773,  769,  771,
    1291       773,  772,  774,  775,  763,  774,  776,  766,  772,  778,
    1292       782,  746,  797,  799,  802,  807,  810,  800,  775,  767,
    1293       801,  803,  804,  801,  803,  804,  806,  808,  811,  776,
    1294       808,  811,  778,  782,  799,  800,  802,  812,  810,  797,
    1295       812,  807,  813,  815,  806,  816,  831,  833,  832,  834,
    1296       833,  813,  835,  836,  815,  832,  836,  837,  834,  840,
    1297 
    1298       843,  816,  840,  843,  844,  845,  846,  831,  858,  855,
    1299       835,  858,  859,  844,  837,  846,  835,  845,  855,  856,
    1300       860,  870,  859,  862,  856,  860,  862,  863,  864,  871,
    1301       863,  864,  872,  873,  874,  872,  875,  874,  878,  875,
    1302       881,  870,  882,  873,  871,  885,  886,  887,  889,  888,
    1303       890,  851,  891,  850,  885,  849,  848,  882,  847,  886,
    1304       878,  881,  891,  842,  841,  839,  889,  838,  830,  887,
    1305       888,  829,  890,  895,  895,  895,  895,  895,  895,  895,
    1306       895,  895,  895,  895,  895,  895,  896,  896,  896,  896,
    1307       896,  896,  896,  896,  896,  896,  896,  896,  896,  897,
    1308 
    1309       897,  897,  897,  897,  897,  897,  897,  897,  897,  897,
    1310       897,  897,  898,  828,  827,  898,  826,  898,  898,  898,
    1311       898,  898,  899,  825,  824,  823,  899,  899,  899,  899,
    1312       899,  899,  900,  900,  900,  900,  900,  900,  900,  900,
    1313       900,  900,  900,  900,  900,  901,  822,  821,  901,  820,
    1314       901,  901,  901,  901,  901,  902,  819,  902,  902,  818,
    1315       902,  902,  902,  902,  902,  902,  817,  902,  903,  809,
    1316       805,  903,  903,  903,  903,  903,  903,  903,  903,  798,
    1317       903,  904,  904,  904,  904,  904,  904,  904,  904,  904,
    1318       904,  904,  904,  904,  905,  905,  796,  905,  795,  794,
    1319 
    1320       793,  905,  906,  792,  791,  906,  790,  906,  906,  906,
    1321       906,  906,  907,  789,  907,  788,  787,  786,  907,  908,
    1322       785,  908,  784,  783,  781,  908,  909,  780,  909,  779,
    1323       777,  770,  909,  910,  768,  910,  756,  755,  754,  910,
    1324       911,  753,  911,  752,  751,  750,  911,  912,  749,  912,
    1325       748,  745,  744,  912,  913,  743,  913,  737,  733,  732,
    1326       913,  914,  730,  914,  729,  712,  704,  914,  915,  701,
    1327       915,  696,  694,  690,  915,  916,  680,  916,  917,  917,
    1328       676,  917,  917,  917,  674,  917,  918,  918,  672,  918,
    1329       919,  669,  666,  919,  665,  919,  919,  919,  919,  919,
    1330 
    1331       920,  664,  920,  663,  662,  661,  920,  921,  658,  921,
    1332       657,  655,  652,  921,  922,  651,  922,  650,  646,  619,
    1333       922,  923,  615,  923,  924,  613,  924,  611,  609,  607,
    1334       924,  925,  601,  925,  926,  595,  593,  926,  591,  926,
    1335       926,  926,  926,  926,  927,  927,  927,  927,  927,  927,
    1336       927,  927,  927,  927,  927,  927,  927,  928,  928,  928,
    1337       928,  928,  928,  928,  928,  928,  928,  928,  928,  928,
    1338       929,  589,  929,  587,  585,  583,  929,  930,  581,  930,
    1339       580,  579,  576,  930,  931,  573,  931,  566,  562,  559,
    1340       931,  932,  556,  932,  933,  551,  933,  546,  543,  520,
    1341 
    1342       933,  934,  516,  934,  935,  514,  935,  512,  510,  508,
    1343       935,  936,  506,  936,  937,  505,  937,  504,  503,  491,
    1344       937,  938,  488,  938,  939,  486,  939,  485,  484,  482,
    1345       939,  940,  480,  940,  941,  477,  941,  475,  473,  471,
    1346       941,  942,  467,  942,  943,  450,  943,  448,  440,  438,
    1347       943,  944,  430,  944,  945,  428,  945,  426,  945,  400,
    1348       945,  946,  398,  946,  396,  946,  394,  946,  947,  947,
    1349       393,  947,  947,  947,  392,  947,  948,  379,  948,  376,
    1350       367,  365,  948,  949,  364,  949,  360,  358,  356,  949,
    1351       950,  354,  950,  350,  348,  347,  950,  951,  346,  951,
    1352 
    1353       952,  336,  952,  321,  298,  277,  952,  953,  275,  953,
    1354       954,  273,  954,  272,  271,  269,  954,  955,  268,  955,
    1355       956,  263,  956,  259,  258,  254,  956,  957,  251,  957,
    1356       958,  250,  239,  958,  238,  958,  958,  958,  958,  958,
    1357       959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
    1358       959,  959,  959,  960,  231,  960,  230,  227,  217,  960,
    1359       961,  215,  961,  962,  214,  962,  213,  207,  206,  962,
    1360       963,  204,  963,  964,  199,  964,  178,  149,  147,  964,
    1361       965,  146,  965,  966,  140,  966,  138,  136,  128,  966,
    1362       967,  125,  967,  968,  124,  968,  120,  101,   98,  968,
    1363 
    1364       969,   95,  969,  970,   93,  970,   86,   72,   70,  970,
    1365       971,   66,  971,  972,   36,  972,   33,   18,   11,  972,
    1366       973,    4,  973,    3,    0,    0,  973,  974,    0,  974,
    1367       975,    0,  975,    0,    0,    0,  975,  976,    0,  976,
    1368       977,    0,  977,    0,  977,    0,  977,  978,    0,  978,
    1369         0,    0,    0,  978,  979,    0,  979,    0,    0,    0,
    1370       979,  980,    0,  980,  981,    0,  981,    0,    0,    0,
    1371       981,  982,    0,  982,  983,    0,  983,    0,    0,    0,
    1372       983,  984,    0,  984,  985,    0,  985,    0,    0,    0,
    1373       985,  986,    0,  986,  987,    0,  987,    0,    0,    0,
    1374 
    1375       987,  988,    0,  988,  989,    0,  989,    0,    0,    0,
    1376       989,  990,    0,  990,  991,    0,    0,  991,    0,  991,
    1377       991,  991,  991,  991,  992,  992,  992,  992,  992,  992,
    1378       992,  992,  992,  992,  992,  992,  992,  993,    0,  993,
    1379         0,    0,    0,  993,  994,    0,  994,  995,    0,  995,
    1380         0,    0,    0,  995,  996,    0,  996,  997,    0,  997,
    1381         0,    0,    0,  997,  998,    0,  998,  999,    0,  999,
    1382         0,    0,    0,  999, 1000,    0, 1000, 1001,    0, 1001,
    1383         0,    0,    0, 1001, 1002,    0, 1002, 1003,    0, 1003,
    1384         0,    0,    0, 1003, 1004,    0, 1004, 1005,    0, 1005,
    1385 
    1386         0,    0,    0, 1005, 1006,    0, 1006, 1007,    0, 1007,
    1387         0,    0,    0, 1007, 1008,    0, 1008, 1009,    0, 1009,
    1388         0,    0,    0, 1009, 1010,    0, 1010,    0,    0,    0,
    1389      1010, 1011,    0, 1011, 1012,    0, 1012,    0,    0,    0,
    1390      1012, 1013,    0, 1013, 1014,    0, 1014,    0,    0,    0,
    1391      1014, 1015,    0, 1015, 1016,    0, 1016,    0,    0,    0,
    1392      1016, 1017,    0, 1017, 1018,    0, 1018, 1019,    0, 1019,
    1393      1020,    0,    0, 1020,    0, 1020, 1020, 1020, 1020, 1020,
    1394      1021,    0, 1021, 1022, 1022, 1022, 1022, 1022, 1022, 1022,
    1395      1022, 1022, 1022, 1022, 1022, 1022, 1023,    0, 1023,    0,
    1396 
    1397         0,    0, 1023, 1024,    0, 1024, 1025,    0, 1025,    0,
    1398         0,    0, 1025, 1026,    0, 1026, 1027,    0, 1027, 1028,
    1399         0, 1028, 1029,    0,    0, 1029,    0, 1029, 1029, 1029,
    1400      1029, 1029, 1030,    0, 1030, 1031,    0, 1031, 1032,    0,
    1401      1032, 1033,    0, 1033, 1034,    0, 1034, 1035,    0, 1035,
    1402      1036,    0, 1036, 1037,    0, 1037,    0,    0,    0, 1037,
    1403      1038,    0, 1038, 1039,    0, 1039,    0,    0,    0, 1039,
    1404      1040,    0, 1040, 1041,    0, 1041, 1042,    0, 1042, 1043,
    1405         0, 1043, 1044,    0, 1044,    0,    0,    0, 1044, 1045,
    1406         0,    0, 1045,    0, 1045, 1045, 1045, 1045, 1045, 1046,
    1407 
    1408         0, 1046, 1047,    0, 1047, 1048,    0, 1048, 1049,    0,
    1409      1049,    0,    0,    0, 1049, 1050,    0, 1050,    0,    0,
    1410         0, 1050, 1051,    0, 1051,    0,    0,    0, 1051, 1052,
    1411         0, 1052, 1053,    0, 1053,    0,    0,    0, 1053, 1054,
    1412         0, 1054,    0,    0,    0, 1054, 1055,    0, 1055,    0,
    1413         0,    0, 1055, 1056,    0, 1056,    0,    0,    0, 1056,
    1414      1057,    0, 1057,    0,    0,    0, 1057, 1058,    0, 1058,
    1415         0,    0,    0, 1058, 1059,    0, 1059,    0,    0,    0,
    1416      1059, 1060,    0, 1060,    0,    0,    0, 1060, 1061,    0,
    1417      1061,    0,    0,    0, 1061, 1062,    0, 1062,    0,    0,
    1418 
    1419         0, 1062, 1063,    0, 1063,    0,    0,    0, 1063, 1064,
    1420         0, 1064,    0,    0,    0, 1064, 1065,    0, 1065,    0,
    1421         0,    0, 1065, 1066,    0, 1066,    0,    0,    0, 1066,
    1422      1067,    0, 1067,    0,    0,    0, 1067, 1068,    0, 1068,
    1423         0,    0,    0, 1068,  894,  894,  894,  894,  894,  894,
    1424       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1425       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1426       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1427       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1428       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1429 
    1430       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1431       894,  894,  894,  894,  894,  894,  894,  894,  894,  894,
    1432       894,  894,  894,  894,  894,  894,  894,  894,  894,  894
     1146       45,   30,   40,   45,   45,   40,   49,   30,   45,   63,
     1147       62,   45,   49,   30,   74,  902,  544,   53,   63,   51,
     1148       61,   30,   62,   55,   30,   31,  109,   31,   31,   31,
     1149
     1150       31,   31,   31,   50,   51,   53,   51,   65,   61,   54,
     1151       74,   55,   50,   88,   31,   51,   50,   55,   31,   54,
     1152      109,   50,   52,  115,   31,   50,   54,   52,  182,  146,
     1153       31,   56,  108,  182,  146,   52,   31,   52,  108,   88,
     1154       52,   60,   31,  128,   52,  128,   60,  115,   56,  152,
     1155       31,   38,  894,   56,  112,   38,   38,   58,   38,   60,
     1156       38,   38,  114,   38,  108,   38,   59,  152,  114,   58,
     1157       58,  117,  112,  146,   38,   38,   38,  189,   59,   58,
     1158      112,  130,   58,  130,  143,   60,   59,  132,   60,  117,
     1159      189,   69,   69,   59,  114,   38,   69,  117,   38,  132,
     1160
     1161      111,  132,   60,   68,   68,   68,   68,   68,   68,  893,
     1162      143,   68,   69,   69,   69,   69,   69,   69,   81,   81,
     1163       81,   81,   81,   81,  154,   38,   38,   78,   78,  133,
     1164      111,  133,   78,  154,   78,  111,  135,  162,  135,   78,
     1165       83,   83,   83,   83,   83,   83,  162,  890,   78,   78,
     1166       78,   78,   84,   84,   84,   84,   84,   84,  111,   78,
     1167      104,  104,  104,  104,  104,  104,  105,  105,  105,  105,
     1168      134,  134,  138,  134,  138,   78,  131,  155,   78,  136,
     1169      136,  136,  173,   78,   78,  153,  157,   78,   78,  140,
     1170      131,  140,  131,  155,  105,   78,  151,  173,   78,  105,
     1171
     1172       78,   78,   78,  153,   78,   86,  156,  160,  157,   86,
     1173       86,  151,  183,  158,   86,   86,  168,   86,  151,   86,
     1174      161,  183,  105,  160,  156,  158,  163,  164,   86,   86,
     1175       86,  106,  164,  106,  106,  106,  106,  106,  106,  168,
     1176      169,  167,  161,  170,  166,  164,  165,  163,  163,   86,
     1177      106,  107,   86,  107,  166,  172,  107,  107,  107,  107,
     1178      107,  107,  167,  165,  170,  171,  106,  169,  177,  175,
     1179      171,  176,  106,  174,  178,  181,  184,  172,  180,  889,
     1180       86,  100,  100,  100,  100,  100,  100,  175,  171,  107,
     1181      174,  176,  181,  180,  185,  177,  178,  100,  100,  100,
     1182
     1183      180,  100,  100,  184,  192,  185,  187,  186,  193,  221,
     1184      190,  221,  887,  188,  100,  185,  185,  187,  188,  100,
     1185      100,  100,  159,  192,  100,  186,  100,  159,  159,  159,
     1186      190,  159,  159,  188,  187,  159,  191,  159,  194,  208,
     1187      196,  191,  159,  159,  159,  195,  159,  197,  251,  212,
     1188      212,  194,  193,  196,  212,  193,  201,  201,  195,  194,
     1189      195,  201,  222,  191,  222,  208,  259,  197,  200,  200,
     1190      200,  200,  200,  200,  251,  287,  200,  201,  201,  201,
     1191      201,  201,  201,  203,  203,  223,  246,  223,  203,  205,
     1192      205,  226,  259,  226,  205,  287,  205,  215,  215,  215,
     1193
     1194      215,  228,  224,  228,  203,  203,  203,  203,  203,  203,
     1195      205,  205,  205,  205,  205,  205,  224,  225,  224,  227,
     1196      227,  246,  227,  229,  229,  229,  231,  239,  231,  225,
     1197      215,  225,  232,  291,  232,  237,  237,  238,  269,  238,
     1198      269,  284,  238,  238,  238,  238,  238,  238,  273,  240,
     1199      239,  240,  432,  270,  240,  270,  291,  284,  237,  244,
     1200      244,  244,  244,  244,  244,  245,  432,  245,  245,  245,
     1201      245,  240,  286,  240,  273,  238,  282,  286,  240,  247,
     1202      247,  247,  247,  247,  247,  248,  248,  248,  248,  248,
     1203      248,  283,  244,  285,  282,  281,  247,  250,  294,  250,
     1204
     1205      245,  293,  250,  250,  250,  250,  250,  250,  281,  283,
     1206      285,  288,  247,  294,  289,  331,  288,  297,  247,  249,
     1207      249,  249,  249,  249,  249,  256,  297,  293,  258,  258,
     1208      258,  258,  258,  258,  289,  249,  298,  249,  331,  249,
     1209      249,  263,  263,  263,  263,  263,  263,  292,  256,  298,
     1210      256,  295,  249,  296,  256,  299,  290,  249,  296,  249,
     1211      256,  258,  249,  300,  249,  292,  302,  295,  295,  306,
     1212      303,  290,  256,  307,  263,  303,  256,  290,  290,  304,
     1213      256,  300,  299,  305,  302,  308,  312,  309,  304,  306,
     1214      305,  307,  309,  310,  311,  313,  314,  315,  310,  316,
     1215
     1216      311,  317,  314,  321,  313,  312,  308,  308,  316,  318,
     1217      319,  322,  320,  315,  318,  319,  317,  320,  323,  325,
     1218      326,  327,  321,  328,  327,  329,  330,  332,  333,  322,
     1219      325,  323,  334,  335,  320,  326,  336,  339,  329,  337,
     1220      338,  334,  328,  341,  342,  333,  343,  332,  330,  344,
     1221      339,  346,  341,  347,  348,  335,  346,  345,  338,  336,
     1222      387,  337,  344,  350,  343,  345,  349,  349,  347,  350,
     1223      387,  349,  348,  349,  357,  357,  357,  357,  358,  358,
     1224      358,  358,  367,  368,  367,  368,  387,  408,  342,  375,
     1225      375,  375,  375,  375,  375,  377,  388,  377,  408,  392,
     1226
     1227      377,  377,  377,  377,  377,  377,  388,  357,  376,  376,
     1228      376,  376,  376,  376,  379,  379,  379,  379,  379,  379,
     1229      411,  409,  388,  392,  376,  410,  376,  413,  376,  376,
     1230      382,  382,  382,  382,  382,  382,  390,  409,  413,  411,
     1231      410,  376,  390,  394,  415,  419,  376,  379,  376,  417,
     1232      886,  376,  420,  376,  380,  380,  380,  380,  380,  380,
     1233      389,  394,  417,  382,  412,  420,  415,  419,  390,  394,
     1234      380,  380,  380,  412,  380,  380,  383,  383,  383,  383,
     1235      383,  383,  426,  389,  418,  389,  879,  380,  426,  389,
     1236      878,  393,  380,  380,  380,  389,  391,  380,  391,  380,
     1237
     1238      418,  391,  391,  391,  391,  391,  391,  389,  414,  383,
     1239      416,  389,  421,  422,  393,  389,  393,  414,  423,  416,
     1240      393,  428,  424,  427,  429,  425,  393,  424,  421,  421,
     1241      430,  436,  428,  437,  391,  422,  423,  434,  393,  439,
     1242      425,  438,  393,  429,  427,  430,  393,  425,  441,  434,
     1243      440,  442,  436,  444,  438,  437,  440,  446,  447,  448,
     1244      442,  449,  439,  441,  450,  451,  452,  454,  444,  456,
     1245      459,  457,  458,  462,  448,  452,  460,  446,  461,  450,
     1246      447,  458,  464,  449,  454,  451,  465,  466,  463,  468,
     1247      469,  459,  456,  457,  466,  462,  460,  463,  461,  465,
     1248
     1249      464,  467,  470,  474,  471,  472,  475,  477,  467,  877,
     1250      470,  526,  469,  477,  468,  475,  472,  504,  505,  476,
     1251      470,  471,  476,  876,  526,  474,  486,  486,  486,  486,
     1252      497,  497,  497,  497,  497,  497,  499,  499,  499,  499,
     1253      499,  499,  525,  504,  505,  528,  497,  529,  497,  530,
     1254      497,  497,  500,  500,  500,  500,  500,  500,  875,  525,
     1255      528,  501,  530,  497,  531,  538,  503,  529,  497,  499,
     1256      497,  501,  502,  497,  502,  497,  503,  502,  502,  502,
     1257      502,  502,  502,  533,  538,  500,  531,  501,  533,  532,
     1258      871,  867,  503,  507,  507,  507,  507,  507,  507,  509,
     1259
     1260      535,  509,  532,  535,  509,  509,  509,  509,  509,  509,
     1261      502,  508,  508,  508,  508,  508,  508,  534,  536,  537,
     1262      539,  540,  542,  543,  864,  546,  547,  508,  534,  508,
     1263      540,  508,  508,  542,  537,  541,  543,  545,  536,  548,
     1264      541,  539,  554,  547,  508,  549,  545,  546,  548,  508,
     1265      549,  508,  551,  552,  508,  555,  508,  556,  551,  554,
     1266      557,  560,  552,  561,  559,  562,  564,  571,  567,  557,
     1267      555,  565,  556,  559,  568,  561,  565,  567,  560,  572,
     1268      562,  564,  573,  568,  576,  575,  578,  582,  577,  571,
     1269      579,  580,  572,  575,  576,  577,  582,  580,  585,  573,
     1270
     1271      583,  586,  579,  588,  630,  863,  634,  728,  578,  630,
     1272      583,  633,  613,  613,  586,  585,  606,  606,  606,  606,
     1273      606,  606,  630,  634,  633,  588,  607,  607,  607,  607,
     1274      607,  607,  609,  614,  609,  613,  728,  609,  609,  609,
     1275      609,  609,  609,  612,  612,  612,  612,  612,  612,  606,
     1276      608,  608,  608,  608,  608,  608,  614,  615,  631,  615,
     1277      632,  635,  615,  638,  637,  631,  608,  636,  608,  632,
     1278      608,  608,  637,  648,  636,  639,  612,  641,  639,  615,
     1279      638,  615,  642,  608,  635,  640,  615,  643,  608,  644,
     1280      608,  645,  649,  608,  647,  608,  650,  642,  640,  641,
     1281
     1282      646,  648,  652,  646,  653,  651,  644,  649,  654,  643,
     1283      656,  647,  657,  645,  651,  658,  650,  654,  662,  663,
     1284      652,  668,  665,  862,  658,  669,  653,  676,  679,  680,
     1285      668,  677,  669,  656,  657,  713,  676,  679,  662,  665,
     1286      712,  677,  718,  715,  680,  713,  663,  699,  699,  699,
     1287      699,  699,  699,  703,  703,  703,  703,  703,  703,  716,
     1288      721,  712,  718,  699,  734,  699,  716,  699,  699,  715,
     1289      717,  719,  734,  720,  719,  717,  720,  723,  721,  725,
     1290      699,  724,  727,  723,  731,  699,  703,  699,  725,  745,
     1291      699,  730,  699,  726,  724,  729,  726,  735,  729,  732,
     1292
     1293      730,  733,  732,  727,  736,  737,  738,  735,  744,  741,
     1294      731,  745,  746,  748,  733,  738,  749,  736,  769,  861,
     1295      767,  748,  772,  769,  768,  749,  737,  741,  744,  770,
     1296      773,  774,  741,  746,  756,  756,  756,  756,  756,  756,
     1297      767,  768,  771,  775,  770,  772,  775,  773,  776,  777,
     1298      779,  781,  771,  779,  781,  782,  783,  774,  785,  783,
     1299      784,  776,  782,  784,  786,  788,  792,  756,  807,  809,
     1300      817,  812,  811,  785,  810,  811,  813,  777,  814,  813,
     1301      816,  814,  818,  820,  860,  818,  824,  786,  788,  792,
     1302      809,  821,  810,  812,  821,  807,  817,  822,  816,  823,
     1303
     1304      822,  825,  824,  826,  841,  820,  842,  843,  823,  844,
     1305      843,  845,  825,  842,  846,  847,  855,  846,  844,  826,
     1306      850,  853,  854,  850,  853,  841,  859,  856,  855,  845,
     1307      865,  854,  847,  866,  868,  845,  856,  868,  866,  865,
     1308      869,  870,  872,  880,  873,  872,  870,  873,  874,  881,
     1309      869,  874,  882,  888,  884,  882,  883,  884,  885,  891,
     1310      895,  885,  892,  880,  881,  896,  883,  897,  899,  895,
     1311      898,  900,  901,  858,  857,  888,  852,  892,  896,  851,
     1312      891,  849,  901,  848,  840,  839,  899,  838,  837,  897,
     1313      836,  898,  835,  900,  905,  905,  905,  905,  905,  905,
     1314
     1315      905,  905,  905,  905,  905,  905,  905,  906,  906,  906,
     1316      906,  906,  906,  906,  906,  906,  906,  906,  906,  906,
     1317      907,  907,  907,  907,  907,  907,  907,  907,  907,  907,
     1318      907,  907,  907,  908,  834,  833,  908,  832,  908,  908,
     1319      908,  908,  908,  909,  831,  830,  829,  909,  909,  909,
     1320      909,  909,  909,  910,  910,  910,  910,  910,  910,  910,
     1321      910,  910,  910,  910,  910,  910,  911,  828,  827,  911,
     1322      819,  911,  911,  911,  911,  911,  912,  815,  912,  912,
     1323      808,  912,  912,  912,  912,  912,  912,  806,  912,  913,
     1324      805,  804,  913,  913,  913,  913,  913,  913,  913,  913,
     1325
     1326      803,  913,  914,  914,  914,  914,  914,  914,  914,  914,
     1327      914,  914,  914,  914,  914,  915,  915,  802,  915,  801,
     1328      800,  799,  915,  916,  798,  797,  916,  796,  916,  916,
     1329      916,  916,  916,  917,  795,  917,  794,  793,  791,  917,
     1330      918,  790,  918,  789,  787,  780,  918,  919,  778,  919,
     1331      766,  765,  764,  919,  920,  763,  920,  762,  761,  760,
     1332      920,  921,  759,  921,  758,  755,  754,  921,  922,  753,
     1333      922,  747,  743,  742,  922,  923,  740,  923,  739,  722,
     1334      714,  923,  924,  711,  924,  706,  704,  700,  924,  925,
     1335      690,  925,  686,  684,  682,  925,  926,  681,  926,  927,
     1336
     1337      927,  678,  927,  927,  927,  675,  927,  928,  928,  674,
     1338      928,  929,  673,  672,  929,  671,  929,  929,  929,  929,
     1339      929,  930,  670,  930,  667,  666,  664,  930,  931,  661,
     1340      931,  660,  659,  655,  931,  932,  628,  932,  624,  622,
     1341      620,  932,  933,  618,  933,  934,  616,  934,  610,  604,
     1342      602,  934,  935,  600,  935,  936,  598,  596,  936,  594,
     1343      936,  936,  936,  936,  936,  937,  937,  937,  937,  937,
     1344      937,  937,  937,  937,  937,  937,  937,  937,  938,  938,
     1345      938,  938,  938,  938,  938,  938,  938,  938,  938,  938,
     1346      938,  939,  592,  939,  590,  589,  587,  939,  940,  584,
     1347
     1348      940,  581,  574,  570,  940,  941,  569,  941,  566,  563,
     1349      558,  941,  942,  553,  942,  943,  550,  943,  527,  523,
     1350      521,  943,  944,  519,  944,  945,  517,  945,  515,  513,
     1351      512,  945,  946,  511,  946,  947,  510,  947,  498,  495,
     1352      493,  947,  948,  492,  948,  949,  491,  949,  489,  487,
     1353      484,  949,  950,  482,  950,  951,  480,  951,  478,  473,
     1354      455,  951,  952,  453,  952,  953,  445,  953,  443,  435,
     1355      433,  953,  954,  431,  954,  955,  405,  955,  403,  955,
     1356      401,  955,  956,  399,  956,  398,  956,  397,  956,  957,
     1357      957,  384,  957,  957,  957,  381,  957,  958,  372,  958,
     1358
     1359      370,  369,  365,  958,  959,  363,  959,  361,  359,  355,
     1360      959,  960,  353,  960,  352,  351,  340,  960,  961,  324,
     1361      961,  962,  301,  962,  280,  278,  276,  962,  963,  275,
     1362      963,  964,  274,  964,  272,  271,  266,  964,  965,  262,
     1363      965,  966,  261,  966,  257,  254,  253,  966,  967,  242,
     1364      967,  968,  241,  234,  968,  233,  968,  968,  968,  968,
     1365      968,  969,  969,  969,  969,  969,  969,  969,  969,  969,
     1366      969,  969,  969,  969,  970,  230,  970,  220,  218,  217,
     1367      970,  971,  216,  971,  972,  210,  972,  209,  207,  202,
     1368      972,  973,  179,  973,  974,  150,  974,  148,  147,  141,
     1369
     1370      974,  975,  139,  975,  976,  137,  976,  129,  126,  125,
     1371      976,  977,  121,  977,  978,  102,  978,   99,   96,   94,
     1372      978,  979,   87,  979,  980,   73,  980,   71,   67,   36,
     1373      980,  981,   33,  981,  982,   18,  982,   11,    4,    3,
     1374      982,  983,    0,  983,    0,    0,    0,  983,  984,    0,
     1375      984,  985,    0,  985,    0,    0,    0,  985,  986,    0,
     1376      986,  987,    0,  987,    0,  987,    0,  987,  988,    0,
     1377      988,    0,    0,    0,  988,  989,    0,  989,    0,    0,
     1378        0,  989,  990,    0,  990,  991,    0,  991,    0,    0,
     1379        0,  991,  992,    0,  992,  993,    0,  993,    0,    0,
     1380
     1381        0,  993,  994,    0,  994,  995,    0,  995,    0,    0,
     1382        0,  995,  996,    0,  996,  997,    0,  997,    0,    0,
     1383        0,  997,  998,    0,  998,  999,    0,  999,    0,    0,
     1384        0,  999, 1000,    0, 1000, 1001,    0,    0, 1001,    0,
     1385     1001, 1001, 1001, 1001, 1001, 1002, 1002, 1002, 1002, 1002,
     1386     1002, 1002, 1002, 1002, 1002, 1002, 1002, 1002, 1003,    0,
     1387     1003,    0,    0,    0, 1003, 1004,    0, 1004, 1005,    0,
     1388     1005,    0,    0,    0, 1005, 1006,    0, 1006, 1007,    0,
     1389     1007,    0,    0,    0, 1007, 1008,    0, 1008, 1009,    0,
     1390     1009,    0,    0,    0, 1009, 1010,    0, 1010, 1011,    0,
     1391
     1392     1011,    0,    0,    0, 1011, 1012,    0, 1012, 1013,    0,
     1393     1013,    0,    0,    0, 1013, 1014,    0, 1014, 1015,    0,
     1394     1015,    0,    0,    0, 1015, 1016,    0, 1016, 1017,    0,
     1395     1017,    0,    0,    0, 1017, 1018,    0, 1018, 1019,    0,
     1396     1019,    0,    0,    0, 1019, 1020,    0, 1020,    0,    0,
     1397        0, 1020, 1021,    0, 1021, 1022,    0, 1022,    0,    0,
     1398        0, 1022, 1023,    0, 1023, 1024,    0, 1024,    0,    0,
     1399        0, 1024, 1025,    0, 1025, 1026,    0, 1026,    0,    0,
     1400        0, 1026, 1027,    0, 1027, 1028,    0, 1028, 1029,    0,
     1401     1029, 1030,    0,    0, 1030,    0, 1030, 1030, 1030, 1030,
     1402
     1403     1030, 1031,    0, 1031, 1032, 1032, 1032, 1032, 1032, 1032,
     1404     1032, 1032, 1032, 1032, 1032, 1032, 1032, 1033,    0, 1033,
     1405        0,    0,    0, 1033, 1034,    0, 1034, 1035,    0, 1035,
     1406        0,    0,    0, 1035, 1036,    0, 1036, 1037,    0, 1037,
     1407     1038,    0, 1038, 1039,    0,    0, 1039,    0, 1039, 1039,
     1408     1039, 1039, 1039, 1040,    0, 1040, 1041,    0, 1041, 1042,
     1409        0, 1042, 1043,    0, 1043, 1044,    0, 1044, 1045,    0,
     1410     1045, 1046,    0, 1046, 1047,    0, 1047,    0,    0,    0,
     1411     1047, 1048,    0, 1048, 1049,    0, 1049,    0,    0,    0,
     1412     1049, 1050,    0, 1050, 1051,    0, 1051, 1052,    0, 1052,
     1413
     1414     1053,    0, 1053, 1054,    0, 1054,    0,    0,    0, 1054,
     1415     1055,    0,    0, 1055,    0, 1055, 1055, 1055, 1055, 1055,
     1416     1056,    0, 1056, 1057,    0, 1057, 1058,    0, 1058, 1059,
     1417        0, 1059,    0,    0,    0, 1059, 1060,    0, 1060,    0,
     1418        0,    0, 1060, 1061,    0, 1061,    0,    0,    0, 1061,
     1419     1062,    0, 1062, 1063,    0, 1063,    0,    0,    0, 1063,
     1420     1064,    0, 1064,    0,    0,    0, 1064, 1065,    0, 1065,
     1421        0,    0,    0, 1065, 1066,    0, 1066,    0,    0,    0,
     1422     1066, 1067,    0, 1067,    0,    0,    0, 1067, 1068,    0,
     1423     1068,    0,    0,    0, 1068, 1069,    0, 1069,    0,    0,
     1424
     1425        0, 1069, 1070,    0, 1070,    0,    0,    0, 1070, 1071,
     1426        0, 1071,    0,    0,    0, 1071, 1072,    0, 1072,    0,
     1427        0,    0, 1072, 1073,    0, 1073,    0,    0,    0, 1073,
     1428     1074,    0, 1074,    0,    0,    0, 1074, 1075,    0, 1075,
     1429        0,    0,    0, 1075, 1076,    0, 1076,    0,    0,    0,
     1430     1076, 1077,    0, 1077,    0,    0,    0, 1077, 1078,    0,
     1431     1078,    0,    0,    0, 1078,  904,  904,  904,  904,  904,
     1432      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1433      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1434      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1435
     1436      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1437      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1438      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1439      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1440      904,  904,  904,  904,  904,  904,  904,  904,  904,  904,
     1441      904
    14331442    } ;
    14341443
    14351444/* Table of booleans, true if rule could match eol. */
    1436 static yyconst flex_int32_t yy_rule_can_match_eol[184] =
     1445static yyconst flex_int32_t yy_rule_can_match_eol[186] =
    14371446    {   0,
    143814471, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     
    14411450    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14421451    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1443     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1444     0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1452    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1453    0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14451454    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14461455    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1447     0, 0, 0, 0,     };
     1456    0, 0, 0, 0, 0, 0,     };
    14481457
    14491458static yy_state_type yy_last_accepting_state;
     
    14731482 * Created On       : Sat Sep 22 08:58:10 2001
    14741483 * Last Modified By : Peter A. Buhr
    1475  * Last Modified On : Wed Oct 26 17:32:30 2016
    1476  * Update Count     : 499
     1484 * Last Modified On : Tue Nov 29 11:32:00 2016
     1485 * Update Count     : 501
    14771486 */
    14781487#line 20 "lex.ll"
     
    15351544
    15361545
    1537 #line 1538 "Parser/lex.cc"
     1546#line 1547 "Parser/lex.cc"
    15381547
    15391548#define INITIAL 0
     
    17301739
    17311740                                   /* line directives */
    1732 #line 1733 "Parser/lex.cc"
     1741#line 1742 "Parser/lex.cc"
    17331742
    17341743        if ( !(yy_init) )
     
    17841793                                {
    17851794                                yy_current_state = (int) yy_def[yy_current_state];
    1786                                 if ( yy_current_state >= 895 )
     1795                                if ( yy_current_state >= 905 )
    17871796                                        yy_c = yy_meta[(unsigned int) yy_c];
    17881797                                }
     
    17901799                        ++yy_cp;
    17911800                        }
    1792                 while ( yy_base[yy_current_state] != 2845 );
     1801                while ( yy_base[yy_current_state] != 2866 );
    17931802
    17941803yy_find_action:
     
    22062215YY_RULE_SETUP
    22072216#line 239 "lex.ll"
     2217{ NUMERIC_RETURN(ONE_T); }                              // CFA
     2218        YY_BREAK
     2219case 72:
     2220YY_RULE_SETUP
     2221#line 240 "lex.ll"
    22082222{ KEYWORD_RETURN(OTYPE); }                              // CFA
    22092223        YY_BREAK
    2210 case 72:
    2211 YY_RULE_SETUP
    2212 #line 240 "lex.ll"
     2224case 73:
     2225YY_RULE_SETUP
     2226#line 241 "lex.ll"
    22132227{ KEYWORD_RETURN(REGISTER); }
    22142228        YY_BREAK
    2215 case 73:
    2216 YY_RULE_SETUP
    2217 #line 241 "lex.ll"
     2229case 74:
     2230YY_RULE_SETUP
     2231#line 242 "lex.ll"
    22182232{ KEYWORD_RETURN(RESTRICT); }                   // C99
    2219         YY_BREAK
    2220 case 74:
    2221 YY_RULE_SETUP
    2222 #line 242 "lex.ll"
    2223 { KEYWORD_RETURN(RESTRICT); }                   // GCC
    22242233        YY_BREAK
    22252234case 75:
     
    22312240YY_RULE_SETUP
    22322241#line 244 "lex.ll"
     2242{ KEYWORD_RETURN(RESTRICT); }                   // GCC
     2243        YY_BREAK
     2244case 77:
     2245YY_RULE_SETUP
     2246#line 245 "lex.ll"
    22332247{ KEYWORD_RETURN(RETURN); }
    22342248        YY_BREAK
    2235 case 77:
    2236 YY_RULE_SETUP
    2237 #line 245 "lex.ll"
     2249case 78:
     2250YY_RULE_SETUP
     2251#line 246 "lex.ll"
    22382252{ KEYWORD_RETURN(SHORT); }
    22392253        YY_BREAK
    2240 case 78:
    2241 YY_RULE_SETUP
    2242 #line 246 "lex.ll"
     2254case 79:
     2255YY_RULE_SETUP
     2256#line 247 "lex.ll"
    22432257{ KEYWORD_RETURN(SIGNED); }
    2244         YY_BREAK
    2245 case 79:
    2246 YY_RULE_SETUP
    2247 #line 247 "lex.ll"
    2248 { KEYWORD_RETURN(SIGNED); }                             // GCC
    22492258        YY_BREAK
    22502259case 80:
     
    22562265YY_RULE_SETUP
    22572266#line 249 "lex.ll"
     2267{ KEYWORD_RETURN(SIGNED); }                             // GCC
     2268        YY_BREAK
     2269case 82:
     2270YY_RULE_SETUP
     2271#line 250 "lex.ll"
    22582272{ KEYWORD_RETURN(SIZEOF); }
    22592273        YY_BREAK
    2260 case 82:
    2261 YY_RULE_SETUP
    2262 #line 250 "lex.ll"
     2274case 83:
     2275YY_RULE_SETUP
     2276#line 251 "lex.ll"
    22632277{ KEYWORD_RETURN(STATIC); }
    22642278        YY_BREAK
    2265 case 83:
    2266 YY_RULE_SETUP
    2267 #line 251 "lex.ll"
     2279case 84:
     2280YY_RULE_SETUP
     2281#line 252 "lex.ll"
    22682282{ KEYWORD_RETURN(STATICASSERT); }               // C11
    22692283        YY_BREAK
    2270 case 84:
    2271 YY_RULE_SETUP
    2272 #line 252 "lex.ll"
     2284case 85:
     2285YY_RULE_SETUP
     2286#line 253 "lex.ll"
    22732287{ KEYWORD_RETURN(STRUCT); }
    22742288        YY_BREAK
    2275 case 85:
    2276 YY_RULE_SETUP
    2277 #line 253 "lex.ll"
     2289case 86:
     2290YY_RULE_SETUP
     2291#line 254 "lex.ll"
    22782292{ KEYWORD_RETURN(SWITCH); }
    22792293        YY_BREAK
    2280 case 86:
    2281 YY_RULE_SETUP
    2282 #line 254 "lex.ll"
     2294case 87:
     2295YY_RULE_SETUP
     2296#line 255 "lex.ll"
    22832297{ KEYWORD_RETURN(THREADLOCAL); }                // C11
    22842298        YY_BREAK
    2285 case 87:
    2286 YY_RULE_SETUP
    2287 #line 255 "lex.ll"
     2299case 88:
     2300YY_RULE_SETUP
     2301#line 256 "lex.ll"
    22882302{ KEYWORD_RETURN(THROW); }                              // CFA
    22892303        YY_BREAK
    2290 case 88:
    2291 YY_RULE_SETUP
    2292 #line 256 "lex.ll"
     2304case 89:
     2305YY_RULE_SETUP
     2306#line 257 "lex.ll"
    22932307{ KEYWORD_RETURN(THROWRESUME); }                // CFA
    22942308        YY_BREAK
    2295 case 89:
    2296 YY_RULE_SETUP
    2297 #line 257 "lex.ll"
     2309case 90:
     2310YY_RULE_SETUP
     2311#line 258 "lex.ll"
    22982312{ KEYWORD_RETURN(TRAIT); }                              // CFA
    22992313        YY_BREAK
    2300 case 90:
    2301 YY_RULE_SETUP
    2302 #line 258 "lex.ll"
     2314case 91:
     2315YY_RULE_SETUP
     2316#line 259 "lex.ll"
    23032317{ KEYWORD_RETURN(TRY); }                                // CFA
    23042318        YY_BREAK
    2305 case 91:
    2306 YY_RULE_SETUP
    2307 #line 259 "lex.ll"
     2319case 92:
     2320YY_RULE_SETUP
     2321#line 260 "lex.ll"
    23082322{ KEYWORD_RETURN(TYPEDEF); }
    2309         YY_BREAK
    2310 case 92:
    2311 YY_RULE_SETUP
    2312 #line 260 "lex.ll"
    2313 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    23142323        YY_BREAK
    23152324case 93:
     
    23262335YY_RULE_SETUP
    23272336#line 263 "lex.ll"
     2337{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2338        YY_BREAK
     2339case 96:
     2340YY_RULE_SETUP
     2341#line 264 "lex.ll"
    23282342{ KEYWORD_RETURN(UNION); }
    23292343        YY_BREAK
    2330 case 96:
    2331 YY_RULE_SETUP
    2332 #line 264 "lex.ll"
     2344case 97:
     2345YY_RULE_SETUP
     2346#line 265 "lex.ll"
    23332347{ KEYWORD_RETURN(UNSIGNED); }
    23342348        YY_BREAK
    2335 case 97:
    2336 YY_RULE_SETUP
    2337 #line 265 "lex.ll"
     2349case 98:
     2350YY_RULE_SETUP
     2351#line 266 "lex.ll"
    23382352{ KEYWORD_RETURN(VALIST); }                     // GCC
    23392353        YY_BREAK
    2340 case 98:
    2341 YY_RULE_SETUP
    2342 #line 266 "lex.ll"
     2354case 99:
     2355YY_RULE_SETUP
     2356#line 267 "lex.ll"
    23432357{ KEYWORD_RETURN(VOID); }
    23442358        YY_BREAK
    2345 case 99:
    2346 YY_RULE_SETUP
    2347 #line 267 "lex.ll"
     2359case 100:
     2360YY_RULE_SETUP
     2361#line 268 "lex.ll"
    23482362{ KEYWORD_RETURN(VOLATILE); }
    2349         YY_BREAK
    2350 case 100:
    2351 YY_RULE_SETUP
    2352 #line 268 "lex.ll"
    2353 { KEYWORD_RETURN(VOLATILE); }                   // GCC
    23542363        YY_BREAK
    23552364case 101:
     
    23612370YY_RULE_SETUP
    23622371#line 270 "lex.ll"
     2372{ KEYWORD_RETURN(VOLATILE); }                   // GCC
     2373        YY_BREAK
     2374case 103:
     2375YY_RULE_SETUP
     2376#line 271 "lex.ll"
    23632377{ KEYWORD_RETURN(WHILE); }
    23642378        YY_BREAK
     2379case 104:
     2380YY_RULE_SETUP
     2381#line 272 "lex.ll"
     2382{ NUMERIC_RETURN(ZERO_T); }                             // CFA
     2383        YY_BREAK
    23652384/* identifier */
    2366 case 103:
    2367 YY_RULE_SETUP
    2368 #line 273 "lex.ll"
     2385case 105:
     2386YY_RULE_SETUP
     2387#line 275 "lex.ll"
    23692388{ IDENTIFIER_RETURN(); }
    23702389        YY_BREAK
    2371 case 104:
    2372 YY_RULE_SETUP
    2373 #line 274 "lex.ll"
     2390case 106:
     2391YY_RULE_SETUP
     2392#line 276 "lex.ll"
    23742393{ ATTRIBUTE_RETURN(); }
    23752394        YY_BREAK
    2376 case 105:
    2377 YY_RULE_SETUP
    2378 #line 275 "lex.ll"
     2395case 107:
     2396YY_RULE_SETUP
     2397#line 277 "lex.ll"
    23792398{ BEGIN BKQUOTE; }
    23802399        YY_BREAK
    2381 case 106:
    2382 YY_RULE_SETUP
    2383 #line 276 "lex.ll"
     2400case 108:
     2401YY_RULE_SETUP
     2402#line 278 "lex.ll"
    23842403{ IDENTIFIER_RETURN(); }
    23852404        YY_BREAK
    2386 case 107:
    2387 YY_RULE_SETUP
    2388 #line 277 "lex.ll"
     2405case 109:
     2406YY_RULE_SETUP
     2407#line 279 "lex.ll"
    23892408{ BEGIN 0; }
    23902409        YY_BREAK
    23912410/* numeric constants */
    2392 case 108:
    2393 YY_RULE_SETUP
    2394 #line 280 "lex.ll"
     2411case 110:
     2412YY_RULE_SETUP
     2413#line 282 "lex.ll"
    23952414{ NUMERIC_RETURN(ZERO); }                               // CFA
    23962415        YY_BREAK
    2397 case 109:
    2398 YY_RULE_SETUP
    2399 #line 281 "lex.ll"
     2416case 111:
     2417YY_RULE_SETUP
     2418#line 283 "lex.ll"
    24002419{ NUMERIC_RETURN(ONE); }                                // CFA
    2401         YY_BREAK
    2402 case 110:
    2403 YY_RULE_SETUP
    2404 #line 282 "lex.ll"
    2405 { NUMERIC_RETURN(INTEGERconstant); }
    2406         YY_BREAK
    2407 case 111:
    2408 YY_RULE_SETUP
    2409 #line 283 "lex.ll"
    2410 { NUMERIC_RETURN(INTEGERconstant); }
    24112420        YY_BREAK
    24122421case 112:
     
    24182427YY_RULE_SETUP
    24192428#line 285 "lex.ll"
     2429{ NUMERIC_RETURN(INTEGERconstant); }
     2430        YY_BREAK
     2431case 114:
     2432YY_RULE_SETUP
     2433#line 286 "lex.ll"
     2434{ NUMERIC_RETURN(INTEGERconstant); }
     2435        YY_BREAK
     2436case 115:
     2437YY_RULE_SETUP
     2438#line 287 "lex.ll"
    24202439{ NUMERIC_RETURN(REALDECIMALconstant); } // must appear before floating_constant
    24212440        YY_BREAK
    2422 case 114:
    2423 YY_RULE_SETUP
    2424 #line 286 "lex.ll"
     2441case 116:
     2442YY_RULE_SETUP
     2443#line 288 "lex.ll"
    24252444{ NUMERIC_RETURN(REALFRACTIONconstant); } // must appear before floating_constant
    24262445        YY_BREAK
    2427 case 115:
    2428 YY_RULE_SETUP
    2429 #line 287 "lex.ll"
     2446case 117:
     2447YY_RULE_SETUP
     2448#line 289 "lex.ll"
    24302449{ NUMERIC_RETURN(FLOATINGconstant); }
    24312450        YY_BREAK
    2432 case 116:
    2433 YY_RULE_SETUP
    2434 #line 288 "lex.ll"
     2451case 118:
     2452YY_RULE_SETUP
     2453#line 290 "lex.ll"
    24352454{ NUMERIC_RETURN(FLOATINGconstant); }
    24362455        YY_BREAK
    24372456/* character constant, allows empty value */
    2438 case 117:
    2439 YY_RULE_SETUP
    2440 #line 291 "lex.ll"
     2457case 119:
     2458YY_RULE_SETUP
     2459#line 293 "lex.ll"
    24412460{ BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24422461        YY_BREAK
    2443 case 118:
    2444 YY_RULE_SETUP
    2445 #line 292 "lex.ll"
     2462case 120:
     2463YY_RULE_SETUP
     2464#line 294 "lex.ll"
    24462465{ strtext->append( yytext, yyleng ); }
    24472466        YY_BREAK
    2448 case 119:
    2449 /* rule 119 can match eol */
    2450 YY_RULE_SETUP
    2451 #line 293 "lex.ll"
     2467case 121:
     2468/* rule 121 can match eol */
     2469YY_RULE_SETUP
     2470#line 295 "lex.ll"
    24522471{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    24532472        YY_BREAK
    24542473/* ' stop highlighting */
    24552474/* string constant */
    2456 case 120:
    2457 YY_RULE_SETUP
    2458 #line 297 "lex.ll"
     2475case 122:
     2476YY_RULE_SETUP
     2477#line 299 "lex.ll"
    24592478{ BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24602479        YY_BREAK
    2461 case 121:
    2462 YY_RULE_SETUP
    2463 #line 298 "lex.ll"
     2480case 123:
     2481YY_RULE_SETUP
     2482#line 300 "lex.ll"
    24642483{ strtext->append( yytext, yyleng ); }
    24652484        YY_BREAK
    2466 case 122:
    2467 /* rule 122 can match eol */
    2468 YY_RULE_SETUP
    2469 #line 299 "lex.ll"
     2485case 124:
     2486/* rule 124 can match eol */
     2487YY_RULE_SETUP
     2488#line 301 "lex.ll"
    24702489{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    24712490        YY_BREAK
    24722491/* " stop highlighting */
    24732492/* common character/string constant */
    2474 case 123:
    2475 YY_RULE_SETUP
    2476 #line 303 "lex.ll"
     2493case 125:
     2494YY_RULE_SETUP
     2495#line 305 "lex.ll"
    24772496{ rm_underscore(); strtext->append( yytext, yyleng ); }
    24782497        YY_BREAK
    2479 case 124:
    2480 /* rule 124 can match eol */
    2481 YY_RULE_SETUP
    2482 #line 304 "lex.ll"
     2498case 126:
     2499/* rule 126 can match eol */
     2500YY_RULE_SETUP
     2501#line 306 "lex.ll"
    24832502{}                                              // continuation (ALSO HANDLED BY CPP)
    24842503        YY_BREAK
    2485 case 125:
    2486 YY_RULE_SETUP
    2487 #line 305 "lex.ll"
     2504case 127:
     2505YY_RULE_SETUP
     2506#line 307 "lex.ll"
    24882507{ strtext->append( yytext, yyleng ); } // unknown escape character
    24892508        YY_BREAK
    24902509/* punctuation */
    2491 case 126:
    2492 YY_RULE_SETUP
    2493 #line 308 "lex.ll"
    2494 { ASCIIOP_RETURN(); }
    2495         YY_BREAK
    2496 case 127:
    2497 YY_RULE_SETUP
    2498 #line 309 "lex.ll"
    2499 { ASCIIOP_RETURN(); }
    2500         YY_BREAK
    25012510case 128:
    25022511YY_RULE_SETUP
     
    25222531YY_RULE_SETUP
    25232532#line 314 "lex.ll"
    2524 { ASCIIOP_RETURN(); }                                   // also operator
     2533{ ASCIIOP_RETURN(); }
    25252534        YY_BREAK
    25262535case 133:
     
    25322541YY_RULE_SETUP
    25332542#line 316 "lex.ll"
     2543{ ASCIIOP_RETURN(); }                                   // also operator
     2544        YY_BREAK
     2545case 135:
     2546YY_RULE_SETUP
     2547#line 317 "lex.ll"
    25342548{ ASCIIOP_RETURN(); }
    25352549        YY_BREAK
    2536 case 135:
    2537 YY_RULE_SETUP
    2538 #line 317 "lex.ll"
     2550case 136:
     2551YY_RULE_SETUP
     2552#line 318 "lex.ll"
     2553{ ASCIIOP_RETURN(); }
     2554        YY_BREAK
     2555case 137:
     2556YY_RULE_SETUP
     2557#line 319 "lex.ll"
    25392558{ ASCIIOP_RETURN(); }                                   // also operator
    25402559        YY_BREAK
    2541 case 136:
    2542 YY_RULE_SETUP
    2543 #line 318 "lex.ll"
     2560case 138:
     2561YY_RULE_SETUP
     2562#line 320 "lex.ll"
    25442563{ NAMEDOP_RETURN(ELLIPSIS); }
    25452564        YY_BREAK
    25462565/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
    2547 case 137:
    2548 YY_RULE_SETUP
    2549 #line 321 "lex.ll"
     2566case 139:
     2567YY_RULE_SETUP
     2568#line 323 "lex.ll"
    25502569{ RETURN_VAL('['); }
    25512570        YY_BREAK
    2552 case 138:
    2553 YY_RULE_SETUP
    2554 #line 322 "lex.ll"
     2571case 140:
     2572YY_RULE_SETUP
     2573#line 324 "lex.ll"
    25552574{ RETURN_VAL(']'); }
    25562575        YY_BREAK
    2557 case 139:
    2558 YY_RULE_SETUP
    2559 #line 323 "lex.ll"
     2576case 141:
     2577YY_RULE_SETUP
     2578#line 325 "lex.ll"
    25602579{ RETURN_VAL('{'); }
    25612580        YY_BREAK
    2562 case 140:
    2563 YY_RULE_SETUP
    2564 #line 324 "lex.ll"
     2581case 142:
     2582YY_RULE_SETUP
     2583#line 326 "lex.ll"
    25652584{ RETURN_VAL('}'); }
    25662585        YY_BREAK
    25672586/* operators */
    2568 case 141:
    2569 YY_RULE_SETUP
    2570 #line 327 "lex.ll"
    2571 { ASCIIOP_RETURN(); }
    2572         YY_BREAK
    2573 case 142:
    2574 YY_RULE_SETUP
    2575 #line 328 "lex.ll"
    2576 { ASCIIOP_RETURN(); }
    2577         YY_BREAK
    25782587case 143:
    25792588YY_RULE_SETUP
     
    26382647case 155:
    26392648YY_RULE_SETUP
     2649#line 341 "lex.ll"
     2650{ ASCIIOP_RETURN(); }
     2651        YY_BREAK
     2652case 156:
     2653YY_RULE_SETUP
    26402654#line 342 "lex.ll"
     2655{ ASCIIOP_RETURN(); }
     2656        YY_BREAK
     2657case 157:
     2658YY_RULE_SETUP
     2659#line 344 "lex.ll"
    26412660{ NAMEDOP_RETURN(ICR); }
    26422661        YY_BREAK
    2643 case 156:
    2644 YY_RULE_SETUP
    2645 #line 343 "lex.ll"
     2662case 158:
     2663YY_RULE_SETUP
     2664#line 345 "lex.ll"
    26462665{ NAMEDOP_RETURN(DECR); }
    26472666        YY_BREAK
    2648 case 157:
    2649 YY_RULE_SETUP
    2650 #line 344 "lex.ll"
     2667case 159:
     2668YY_RULE_SETUP
     2669#line 346 "lex.ll"
    26512670{ NAMEDOP_RETURN(EQ); }
    26522671        YY_BREAK
    2653 case 158:
    2654 YY_RULE_SETUP
    2655 #line 345 "lex.ll"
     2672case 160:
     2673YY_RULE_SETUP
     2674#line 347 "lex.ll"
    26562675{ NAMEDOP_RETURN(NE); }
    26572676        YY_BREAK
    2658 case 159:
    2659 YY_RULE_SETUP
    2660 #line 346 "lex.ll"
     2677case 161:
     2678YY_RULE_SETUP
     2679#line 348 "lex.ll"
    26612680{ NAMEDOP_RETURN(LS); }
    26622681        YY_BREAK
    2663 case 160:
    2664 YY_RULE_SETUP
    2665 #line 347 "lex.ll"
     2682case 162:
     2683YY_RULE_SETUP
     2684#line 349 "lex.ll"
    26662685{ NAMEDOP_RETURN(RS); }
    26672686        YY_BREAK
    2668 case 161:
    2669 YY_RULE_SETUP
    2670 #line 348 "lex.ll"
     2687case 163:
     2688YY_RULE_SETUP
     2689#line 350 "lex.ll"
    26712690{ NAMEDOP_RETURN(LE); }
    26722691        YY_BREAK
    2673 case 162:
    2674 YY_RULE_SETUP
    2675 #line 349 "lex.ll"
     2692case 164:
     2693YY_RULE_SETUP
     2694#line 351 "lex.ll"
    26762695{ NAMEDOP_RETURN(GE); }
    26772696        YY_BREAK
    2678 case 163:
    2679 YY_RULE_SETUP
    2680 #line 350 "lex.ll"
     2697case 165:
     2698YY_RULE_SETUP
     2699#line 352 "lex.ll"
    26812700{ NAMEDOP_RETURN(ANDAND); }
    26822701        YY_BREAK
    2683 case 164:
    2684 YY_RULE_SETUP
    2685 #line 351 "lex.ll"