diff --git a/.Rbuildignore b/.Rbuildignore index ad879553c..afe8fb8b0 100644 --- a/.Rbuildignore +++ b/.Rbuildignore @@ -9,6 +9,7 @@ ^Meta$ ^doc$ .Rdata +.projectile ^\.travis.yml$ ^\.lintr$ ^.git.*$ diff --git a/.github/workflows/R-CMD-check.yaml b/.github/workflows/R-CMD-check.yaml index 6baac3bea..d52562958 100644 --- a/.github/workflows/R-CMD-check.yaml +++ b/.github/workflows/R-CMD-check.yaml @@ -50,13 +50,14 @@ jobs: - uses: r-lib/actions/setup-r-dependencies@v2 with: - cache-version: 7 + cache-version: 9 pak-version: stable extra-packages: | any::rcmdcheck nlmixr2/dparser-R nlmixr2/lotri nlmixr2/rxode2ll + nlmixr2/PreciseSums needs: check - uses: r-lib/actions/check-r-package@v2 diff --git a/.github/workflows/pkgdown.yaml b/.github/workflows/pkgdown.yaml index 0e295dccd..d046bd722 100644 --- a/.github/workflows/pkgdown.yaml +++ b/.github/workflows/pkgdown.yaml @@ -38,12 +38,13 @@ jobs: - uses: r-lib/actions/setup-r-dependencies@v2 with: - cache-version: 6 + cache-version: 8 extra-packages: | any::pkgdown nlmixr2/dparser-R nlmixr2/lotri nlmixr2/rxode2ll + nlmixr2/PreciseSums local::. needs: website diff --git a/.github/workflows/test-coverage.yaml b/.github/workflows/test-coverage.yaml index 12aae2a2b..4552f8f1e 100644 --- a/.github/workflows/test-coverage.yaml +++ b/.github/workflows/test-coverage.yaml @@ -26,12 +26,13 @@ jobs: - uses: r-lib/actions/setup-r-dependencies@v2 with: - cache-version: 6 + cache-version: 8 extra-packages: | any::covr nlmixr2/dparser-R nlmixr2/lotri nlmixr2/rxode2ll + nlmixr2/PreciseSums needs: coverage - name: Test coverage diff --git a/DESCRIPTION b/DESCRIPTION index 4b2d7e8d6..5b68bcffc 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -1,5 +1,5 @@ Package: rxode2 -Version: 2.1.3.9000 +Version: 3.0.2 Title: Facilities for Simulating from ODE-Based Models Authors@R: c( person("Matthew L.","Fidler", role = c("aut", "cre"), email = "matthew.fidler@gmail.com", comment=c(ORCID="0000-0001-8538-6691")), @@ -26,6 +26,7 @@ Authors@R: c( person("Matt", "Dowle", role="ctb", email="mattjdowle@gmail.com"), person("Matteo", "Fasiolo", email = "matteo.fasiolo@gmail.com", role = "ctb"), person("Melissa", "Hallow", role = "aut", email = "hallowkm@uga.edu"), + person("Michel", "Lang", , "michellang@gmail.com", role = "ctb"), person("Morwenn","", role="ctb"), person("Nicholas J.", "Higham",role="ctb"), person("Omar", "Elashkar", email="omar.i.elashkar@gmail.com", role="ctb"), @@ -75,14 +76,14 @@ Suggests: lifecycle, kableExtra Imports: - PreciseSums (>= 0.3), + PreciseSums (>= 0.7), Rcpp (>= 0.12.3), backports, cli (>= 2.0.0), checkmate, ggplot2 (>= 3.4.0), inline, - lotri (>= 0.4.0), + lotri (>= 1.0.0), magrittr, memoise, methods, @@ -90,7 +91,7 @@ Imports: sys, tools, utils, - dparser, + dparser (>= 1.3.1-12), rxode2ll(>= 2.0.9), data.table (>= 1.12.4), qs (>= 0.26.3) @@ -116,14 +117,15 @@ RoxygenNote: 7.3.2 Biarch: true LinkingTo: sitmo, - PreciseSums (>= 0.3), + lotri (>= 1.0.0), + PreciseSums (>= 0.7), Rcpp, RcppArmadillo (>= 0.9.300.2.0), BH, RcppParallel, RcppEigen (>= 0.3.3.9.2), StanHeaders (>= 2.21.0.7), - dparser + dparser (>= 1.3.1-12) Encoding: UTF-8 LazyData: true Language: en-US diff --git a/NAMESPACE b/NAMESPACE index f25be5128..7a60f585a 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -27,6 +27,7 @@ S3method("ini<-",default) S3method("model<-",default) S3method("rxode2<-","function") S3method("rxode2<-",default) +S3method("units<-",rxEvid) S3method(.DollarNames,rxEt) S3method(.DollarNames,rxSolve) S3method(.DollarNames,rxUi) @@ -157,6 +158,46 @@ S3method(rxSolve,rxUi) S3method(rxSolve,rxode2tos) S3method(rxTrans,character) S3method(rxTrans,default) +S3method(rxUdfUi,default) +S3method(rxUdfUi,linMod) +S3method(rxUdfUi,linMod0) +S3method(rxUdfUi,linModA) +S3method(rxUdfUi,linModA0) +S3method(rxUdfUi,linModB) +S3method(rxUdfUi,linModB0) +S3method(rxUdfUi,linModD) +S3method(rxUdfUi,linModD0) +S3method(rxUdfUi,linModM) +S3method(rxUdfUi,linModM0) +S3method(rxUdfUi,ribeta) +S3method(rxUdfUi,ribinom) +S3method(rxUdfUi,ricauchy) +S3method(rxUdfUi,richisq) +S3method(rxUdfUi,riexp) +S3method(rxUdfUi,rif) +S3method(rxUdfUi,rigamma) +S3method(rxUdfUi,rigeom) +S3method(rxUdfUi,rinorm) +S3method(rxUdfUi,ripois) +S3method(rxUdfUi,rit) +S3method(rxUdfUi,riunif) +S3method(rxUdfUi,riweibull) +S3method(rxUdfUi,rxbeta) +S3method(rxUdfUi,rxbinom) +S3method(rxUdfUi,rxcauchy) +S3method(rxUdfUi,rxchisq) +S3method(rxUdfUi,rxexp) +S3method(rxUdfUi,rxf) +S3method(rxUdfUi,rxgamma) +S3method(rxUdfUi,rxgeom) +S3method(rxUdfUi,rxnorm) +S3method(rxUdfUi,rxpois) +S3method(rxUdfUi,rxt) +S3method(rxUdfUi,rxunif) +S3method(rxUdfUi,rxweibull) +S3method(rxUiDeparse,default) +S3method(rxUiDeparse,lotriFix) +S3method(rxUiDeparse,rxControl) S3method(rxUiGet,allCovs) S3method(rxUiGet,cmtLines) S3method(rxUiGet,covLhs) @@ -169,6 +210,8 @@ S3method(rxUiGet,funPrint) S3method(rxUiGet,funTxt) S3method(rxUiGet,ini) S3method(rxUiGet,iniFun) +S3method(rxUiGet,interpLines) +S3method(rxUiGet,levels) S3method(rxUiGet,lhsCov) S3method(rxUiGet,lhsEta) S3method(rxUiGet,lhsTheta) @@ -182,13 +225,14 @@ S3method(rxUiGet,muRefTable) S3method(rxUiGet,multipleEndpoint) S3method(rxUiGet,mvFromExpression) S3method(rxUiGet,omega) -S3method(rxUiGet,params) S3method(rxUiGet,paramsLine) +S3method(rxUiGet,props) S3method(rxUiGet,simulationIniModel) S3method(rxUiGet,simulationModel) S3method(rxUiGet,simulationSigma) S3method(rxUiGet,state) S3method(rxUiGet,stateDf) +S3method(rxUiGet,statePropDf) S3method(rxUiGet,symengineModelNoPrune) S3method(rxUiGet,symengineModelPrune) S3method(rxUiGet,theta) @@ -262,6 +306,7 @@ export(.pipeRx) export(.pipeSigma) export(.pipeThetaMat) export(.quoteCallInfoLines) +export(.rxBlankIni) export(.rxC) export(.rxDocTable) export(.rxFromSE) @@ -281,10 +326,12 @@ export(.rxSEeqUsr) export(.rxSens) export(.rxToSE) export(.rxTransInfo) +export(.rxTransform) export(.rxWithOptions) export(.rxWithSink) export(.rxWithSinkBoth) export(.rxWithWd) +export(.rxode2ptrs) export(.s3register) export(.solComp2) export(.solComp3) @@ -312,6 +359,7 @@ export(assertCompartmentExists) export(assertCompartmentName) export(assertCompartmentNew) export(assertExists) +export(assertIniDf) export(assertParameterValue) export(assertRxLinCmt) export(assertRxUi) @@ -324,10 +372,13 @@ export(assertRxUiPrediction) export(assertRxUiRandomOnIdOnly) export(assertRxUiSingleEndpoint) export(assertRxUiTransformNormal) +export(assertRxUnbounded) export(assertVariableExists) export(assertVariableName) export(assertVariableNew) export(binomProbs) +export(boxCox) +export(boxCoxInv) export(cvPost) export(dfWishart) export(erf) @@ -369,6 +420,15 @@ export(label_both) export(label_context) export(label_value) export(label_wrap_gen) +export(linMod) +export(linMod0) +export(linModA0) +export(linModB) +export(linModB0) +export(linModD) +export(linModD0) +export(linModM) +export(linModM0) export(llikBeta) export(llikBinom) export(llikCauchy) @@ -450,6 +510,8 @@ export(rxIndLinState) export(rxIndLinStrategy) export(rxInit) export(rxInits) +export(rxIntToBase) +export(rxIntToLetter) export(rxInv) export(rxIs) export(rxIsCurrent) @@ -520,8 +582,18 @@ export(rxTheme) export(rxTick) export(rxToSE) export(rxTrans) +export(rxUdfUi) +export(rxUdfUiData) +export(rxUdfUiEst) +export(rxUdfUiIniDf) +export(rxUdfUiIniLhs) +export(rxUdfUiMv) +export(rxUdfUiNum) +export(rxUdfUiParsing) +export(rxUdfUiReset) export(rxUiCompress) export(rxUiDecompress) +export(rxUiDeparse) export(rxUiGet) export(rxUnload) export(rxUnloadAll) @@ -571,14 +643,19 @@ export(stat_cens) export(swapMatListWithCube) export(testCompartmentExists) export(testExists) +export(testIniDf) export(testRxLinCmt) +export(testRxUnbounded) export(testVariableExists) export(toTrialDuration) export(uppergamma) export(waiver) +export(warnRxBounded) export(write.template.server) export(write.template.ui) export(xlab) +export(yeoJohnson) +export(yeoJohnsonInv) export(ylab) export(zeroRe) import(data.table) diff --git a/NEWS.md b/NEWS.md index 967caf093..faddb7c0a 100644 --- a/NEWS.md +++ b/NEWS.md @@ -1,7 +1,36 @@ -# rxode2 (development version) +# rxode2 3.0.2 + +- Bug fix for `api`, the censoring function pointer has been updated + (#801). + +- Query `rxode2.verbose.pipe` at run time instead of requiring it to + be set before loading `rxode2`. + +- Have correct values at boundaries for `logit`, `expit`, `probit`, + and `probitInv` (instead of `NA`). For most cases this does not + break anything. + +- Add a new style of user function that modifies the `ui` while + parsing or just before using the function (in the presence of + `data`). + +- Used the new user function interface to allow all random functions + in `rxode2` ui functions to be named. For example, you can use + `rxnorm(sd=3)` instead of having to use `rxnorm(0, 3)`, although + `rxnorm()` still works. + +# rxode2 3.0.1 + +- Explicitly initialize the order vector to stop valgrind warning + (requested from CRAN) + +# rxode2 3.0.0 ## Breaking Changes +- The model properties was moved from `$params` to `$props` so it does + not conflict with the low level `rxode2` model `$params` + - Error when specifying `wd` without `modName` - With Linear and midpoint of a time between two points, how `rxode2` @@ -12,13 +41,65 @@ the algorithm will look forward until it finds the first non-missing value (or if all are missing, start looking backward). +- The order of ODEs is now only determined by the order of `cmt()` and + `d/dt()`. Compartment properties, `tad()` and other compartment + related variables no no longer affect compartment sorting. The + option `rxode2.syntax.require.ode.first` no longer does anything. + +- The handling of zeros "safely" has changed (see #775) + + - when `safeZero=TRUE` and the denominator of a division expression + is zero, use the Machine's small number/`eps` (you can see this + value with `.Machine$double.eps`) + + - when `saveLog=TRUE` and the x in the `log(x)` is less than or + equal to zero, change this to `log(eps)` + + - when `safePow=TRUE` and the expression `x^y` has a zero for `x` + and a negative number for `y` replace `x` with `eps`. + + Since the protection for divide by zero has changed, the results + will also change. This is a more conservative protection mechanism + than was applied previously. + +- Random numbers from `rxode2` are different when using `dop853`, + `lsoda` or `indLin` methods. These now seed the random numbers in + the same way as `liblsoda`, so the random number provided will be + the same with different solving methods. + +- The arguments saved in the `rxSolve` for items like `thetaMat` will + be the reduced matrices used in solving, not the full matrices (this + will likely not break very many items) + ## Possible breaking changes (though unlikely) - `iCov` is no longer merged to the event dataset. This makes solving with `iCov` slightly faster (#743) + ## New features +- You can remove covariances for every omega by piping with `%>% + ini(diag())` you can be a bit more granular by removing all + covariances that have either `eta.ka` or `eta.cl` by: `%>% + ini(diag(eta.ka, eta.cl))` or anything with correlations with + `eta.cl` with `%>% ini(diag(eta.cl))` + +- You can also remove individual covariances by `%>% ini(-cov(a, b))` + or `%>% ini(-cor(a,b))`. + +- You can specify the type of interpolation applied for added dosing + records (or other added records) for columns that are kept with the + `keep=` option in `rxSolve()`. This new option is + `keepInterpolation` and can be `locf` for last observation carried + forward, `nocb` which is the next observation carried backward, as + well as `NA` which puts a `NA` in all imputed data rows. See #756. + + - Note: when interpolation is linear/midpoint for + factors/characters it changes to locf with a warning (#759) + + - Also note, that the default keep interpolation is `na` + - Now you can specify the interpolation method per covariate in the model: - `linear(var1, var2)` says both `var1` and `var2` would use linear @@ -35,6 +116,16 @@ and `dvid()` declarations are now ignored when loading a `rxode2` model with `rxS()` +- Strings can be assigned to variables in `rxode2`. + +- Strings can now be enclosed with a single quote as well as a double + quote. This limitation was only in the rxode2 using string since + the R-parser changes single quotes to double quotes. (This has no + impact with `rxode2({})` and ui/function form). + +- More robust string encoding for symengine (adapted from + `utils::URLencode()` and `utils::URLdecode()`) + - Empty arguments to `rxRename()` give a warning (#688) - Promoting from covariates to parameters with model piping (via `ini()`) now @@ -48,15 +139,44 @@ compartment name, nlmixr2 compartment/variable exists in the model, variable name, or parameter value (#726; #733) +- Added `assertRxUnbounded()`, `testRxUnbounded()`, `warnRxBounded()` + to allow `nlmixr2` warn about methods that ignore boundaries #760 + - Added functions `tad0()`, `tafd0()`, `tlast0()` and `tfirst0()` that will give `0` instead of `NA` when the dose has not been administered yet. This is useful for use in ODEs since `NA`s will break the solving (so can be used a bit more robustly with models like Weibull absorption). +- `rxode2` is has no more binary link to `lotri`, which means that + changes in the `lotri` package will not require `rxode2` to be + recompiled (in most cases) and will not crash the system. + +- `rxode2` also has no more binary linkage to `PreciseSums` + +- The binary linkage for `dparser` is reduced to C structures only, + making changes in dparser less likely to cause segmentation faults + in `rxode2` if it wasn't recompiled. + +- A new model property has been added to `$props$cmtProp` and + `$statePropDf`. Both are data-frames showing which compartment has + properties (currently `ini`, `f`, `alag`, `rate` and `dur`) + in the `rxode2` ui model. This comes from the lower + level model variable `$stateProp` which has this information + encoded in integers for each state. + +- A new generic method `rxUiDeparse` can be used to deparse meta + information into more readable expressions; This currently by + default supports lower triangular matrices by lotri, but can be + extended to support other types of objects like 'nlmixr2's + `foceiControl()` for instance. + ## Bug fixes -- Fix `ui$params` when the ui is a linear compartment model without `ka` defined. +- Fix `ui$props$endpoint` when the ui endpoint is defined in terms of + the ode instead of lhs. See #754 + +- Fix `ui$props` when the ui is a linear compartment model without `ka` defined. - Model extraction `modelExtract()` will now extract model properties. Note that the model property of `alag(cmt)` and `lag(cmt)` will give the same value. See #745 @@ -65,6 +185,16 @@ - Linear interpolation will now adjust the times as well as the values when `NA` values are observed. +- Fix when keeping data has `NA` values that it will not crash R; Also + fixed some incorrect `NA` interpolations. See #756 + +- When using `cmt()` sometimes the next statement would be corrupted + in the normalized syntax (like for instance `locf`); This bug was + fixed (#763) + +- `keep` will now error when trying to keep items that are in the + rxode2 output data-frame and will be calculated (#764) + ## Big change - At the request of CRAN, combine `rxode2parse`, `rxode2random`, and diff --git a/R/RcppExports.R b/R/RcppExports.R index 4a18abbb0..d2cf89678 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -116,25 +116,6 @@ etRep_ <- function(curEt, times, wait, ids, handleSamples, waitType, ii) { .Call(`_rxode2_etRep_`, curEt, times, wait, ids, handleSamples, waitType, ii) } -#' Force using base order for rxode2 radix sorting -#' -#' @param forceBase boolean indicating if rxode2 should use R's -#' [order()] for radix sorting instead of -#' `data.table`'s parallel radix sorting. -#' -#' @return NILL; called for side effects -#' -#' @examples -#' \donttest{ -#' forderForceBase(TRUE) # Use base `order` for rxode2 sorts -#' forderForceBase(FALSE) # Use `data.table` for rxode2 sorts -#' } -#' @export -#' @keywords internal -forderForceBase <- function(forceBase = FALSE) { - .Call(`_rxode2_forderForceBase`, forceBase) -} - #' Set Initial conditions to time zero instead of the first observed/dosed time #' #' @param ini0 When `TRUE` (default), set initial conditions to time diff --git a/R/assert.R b/R/assert.R index 0335a0660..fef90bb5b 100644 --- a/R/assert.R +++ b/R/assert.R @@ -532,3 +532,119 @@ testExists <- function(ui, x) { if (.vn %in% c(.mv$lhs, .mv$params, .mv$state)) return(TRUE) FALSE } + +#' Check if parameters have user boundaries different than defaults +#' +#' @param ui rxode2 ui +#' @param extra extra information to append to the error message +#' @param .var.name variable name +#' @return a named logical vector indicating whether each parameter is bounded +#' @noRd +#' @author Matthew L. Fidler +.getRxBounded <- function(ui, extra="", .var.name=.vname(ui)) { + .ui <- assertRxUi(ui, extra=extra, .var.name=.var.name) + .iniDf <- .ui$iniDf + .theta <- .iniDf[which(!is.na(.iniDf$ntheta)),] + setNames(vapply(seq_along(.theta$name), + function(i) { + .t <- .theta[i,] + if (is.na(.t$err)) { + return(is.finite(.t$upper) || is.finite(.t$lower)) + } + .err <- .errDistArgRanges[[.t$err]] + return (!identical(.t$lower, .err[1]) || + !identical(.t$upper, .err[2])) + }, logical(1), USE.NAMES=FALSE), .theta$name) +} +#' Test if the rxode2 model has any parameters with user defined boundaries +#' +#' @param ui rxode2 ui +#' @param extra extra information to append to the error message +#' @param .var.name variable name +#' @return boolean indicating if any parameters have user defined boundaries +#' @family Assertions +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' one.cmt <- function() { +#' ini({ +#' tka <- 0.45; label("Ka") +#' tcl <- log(c(0, 2.7, 100)); label("Cl") +#' tv <- 3.45; label("V") +#' eta.ka ~ 0.6 +#' eta.cl ~ 0.3 +#' eta.v ~ 0.1 +#' add.sd <- 0.7 +#' }) +#' model({ +#' ka <- exp(tka + eta.ka) +#' cl <- exp(tcl + eta.cl) +#' v <- exp(tv + eta.v) +#' linCmt() ~ add(add.sd) +#' }) +#' } +#' +#' testRxUnbounded(one.cmt) +#' +#' try(assertRxUnbounded(one.cmt)) +#' +#' warnRxBounded(one.cmt) +testRxUnbounded <- function(ui) { + !any(.getRxBounded(ui)) +} + +#' @describeIn testRxUnbounded Assert that the rxode2 model has any parameters with user defined boundaries +#' @export +assertRxUnbounded <- function(ui, extra="", .var.name=.vname(ui)) { + if (testRxUnbounded(ui)) { + return(invisible(ui)) + } + stop("'", .var.name, "' can not have user defined boundaries", extra, call.=FALSE) +} + +#' @describeIn testRxUnbounded Warn that the rxode2 model has any parameters with user defined boundaries +#' @export +warnRxBounded <- function(ui, extra="", .var.name=.vname(ui)) { + .bound <- .getRxBounded(ui, extra=extra, .var.name=.var.name) + .w <- which(.bound) + if (length(.w) > 0) { + warning("'", .var.name, "' has the following user-defined boundaries: ", + paste(names(.bound)[.w], collapse=", "), + extra, call.=FALSE) + } + invisible() +} + +#' This function tests if this object is a iniDf as needed by the UI +#' +#' +#' @param iniDf the object to test if it is a rxode2 ui `iniDf` data.frame +#' @param extra information to append to the error message +#' @inheritParams checkmate::testDataFrame +#' @return boolean, indicating if the object is a valid initialization data frame +#' @export +#' @author Matthew L. Fidler +#' @family Assertions +#' @examples +#' testIniDf(TRUE) +testIniDf <- function(iniDf) { + if (checkmate::testDataFrame(iniDf)) { + checkmate::testSubset(names(iniDf), + c("ntheta", "neta1", "neta2", "name", "lower", "est", "upper", + "fix", "label", "backTransform", "condition", "err")) + } else { + FALSE + } +} +#' @describeIn testIniDf Assert that the object is a valid rxode2 ui initialization data frame +#' @export +assertIniDf <- function(iniDf, extra="", .var.name=.vname(iniDf), null.ok = FALSE) { + if (testIniDf(iniDf)) { + return(invisible(iniDf)) + } + if (null.ok && is.null(iniDf)) { + return(invisible(NULL)) + } + stop("'", .var.name, "' is not a rxode2 ui initial conditions data.frame", extra, call.=FALSE) +} diff --git a/R/build.R b/R/build.R index d0896c3f3..8ca93c905 100644 --- a/R/build.R +++ b/R/build.R @@ -59,9 +59,81 @@ d/dt(blood) = a*intestine - b*blood sink() # nolint } +.generateRandomUiFun <- function(fun, args, vals=NULL) { + .ret <- as.call(c( + quote(`{`), + do.call(`c`, + lapply(args, function(arg) { + .dotArg <- str2lang(paste0(".", arg)) + .arg <- str2lang(arg) + .ret <- bquote({ + .(.dotArg) <- as.character(substitute(.(.arg))) + .tmp <- suppressWarnings(try(force(.(.arg)), silent=TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .(.dotArg) <- .(.arg) + } + } + }) + lapply(seq_along(.ret)[-1], function(i) { + .ret[[i]] + }) + })), + str2lang(paste0("list(replace=paste0('", fun, "(', ", paste(paste0(".", args), collapse=", ', ', "), ", ')'))")) + )) + if (is.null(vals)) { + .f <- paste0(".", fun, " <- function(", paste(args, collapse=", "), ") ", + paste(deparse(.ret), collapse="\n"), + "\n") + } else { + .f <- paste0(".", fun, " <- function(", paste0(paste0(args, ifelse(is.na(vals), "", " = "), ifelse(is.na(vals), "", vals)), + collapse=", "), ") ", + paste(deparse(.ret), collapse="\n"), + "\n") + } + .f <- paste0(.f, "\n#'@export\nrxUdfUi.", fun, " <- rxUdfUi.rxpois\n\n") + .f +} + +.generateRandomUiFuns <- function() { + .lst <- list("rxnorm"=c("mean"=0, "sd"=1), + "rxpois"="lambda", + "rxt"="df", + "rxunif"=c("min"=0, "max"=1), + "rxweibull"=c("shape"=NA, "scale"=1), + "rxgeom"="prob", + "rxbeta"=c("shape1", "shape2"), + "rxgamma"=c("shape"=NA, "rate"=1), + "rxf"=c("df1","df2"), + "rxexp"="rate", + "rxchisq"="df", + "rxcauchy"=c(location = 0, scale = 1), + "rxbinom"=c("size", "prob")) + .lst2 <- .lst + names(.lst2) <- gsub("rx", "ri", names(.lst2)) + .lst <- c(.lst, .lst2) + paste0("# This file is generated by .generateRandomUiFuns() in build.R\n## nocov start\n", + vapply(names(.lst), function(fun) { + if (is.null(names(.lst[[fun]]))) { + .generateRandomUiFun(fun, .lst[[fun]]) + } else { + .generateRandomUiFun(fun, names(.lst[[fun]]), .lst[[fun]]) + } + }, character(1), USE.NAMES=FALSE), + "## nocov end") +} + .rxodeBuildCode <- function() { # This builds the code needed for rxode2 + message("Generate rxode2 random named arguments option") + + .l <- .generateRandomUiFuns() + .R <- file(devtools::package_file("R/rxrandomui.R"), "wb") + writeLines(.l, .R) + close(.R) + + message("done") message("Generate grammar include file") dparser::mkdparse(devtools::package_file("inst/tran.g"), devtools::package_file("src/"), diff --git a/R/err-sim.R b/R/err-sim.R index 71990aac6..4dd014383 100644 --- a/R/err-sim.R +++ b/R/err-sim.R @@ -135,9 +135,9 @@ rxGetDistributionSimulationLines.ordinal <- function(line) { .ret[[1]] <- quote(ipredSim <- NA) .ret[[2]] <- str2lang(paste0("rx_sim_~rxord(", paste(.n, collapse=", "), ")")) .ce <- setNames(.ce, NULL) - + .ret[[3]] <- str2lang(paste0("sim<-", paste(vapply(seq_along(.ce), function(i) { - paste("(rx_sim_ == ", i, ")*", .ce[i]) + paste("(rx_sim_ == ", i, ")*", .ce[i]) }, character(1), USE.NAMES=FALSE), collapse="+"))) return(.ret) } @@ -200,6 +200,56 @@ rxUiGet.paramsLine <- function(x, ...) { } attr(rxUiGet.paramsLine, "desc") <- "params() line for model" +#' @export +#' @rdname rxUiGet +rxUiGet.interpLines <- function(x, ...){ + .ui <- x[[1]] + .interp <- rxModelVars(.ui)$interp + if (!is.factor(.interp) || + length(.interp) == 0) { + return(NULL) + } + .lvl <- levels(.interp) + if (length(.lvl) != 5L || + !identical(.lvl, c("default", "linear", "locf", "nocb", "midpoint"))) { + return(NULL) + } + if (any(is.na(.interp))) { + return(NULL) + } + .try <- try(all(.interp == "default"), silent=TRUE) + if (inherits(.try, "try-error") || + !checkmate::testLogical(.try, any.missing=FALSE, len=1)) { + return(NULL) + } + if (.try) { + # use default + return(NULL) + } + .ret <- list() + .w <- which(.interp=="linear") + if (length(.w) > 0) { + .ret <- list(str2lang(paste("linear(",paste(names(.interp)[.w], collapse=", "), ")"))) + } + .w <- which(.interp=="locf") + if (length(.w) > 0) { + .ret <- c(.ret, list(str2lang(paste("locf(",paste(names(.interp)[.w], collapse=", "), ")")))) + } + .w <- which(.interp=="nocb") + if (length(.w) > 0) { + .ret <- c(.ret, list(str2lang(paste("nocb(",paste(names(.interp)[.w], collapse=", "), ")")))) + } + .w <- which(.interp=="midpoint") + if (length(.w) > 0) { + .ret <- c(.ret, list(str2lang(paste("midpoint(",paste(names(.interp)[.w], collapse=", "), ")")))) + } + if (length(.ret) == 0) { + return(NULL) #nocov + } + .ret +} +attr(rxUiGet.interpLines, "desc") <- "interpolation declaration line(s) for model" + #' @export #' @rdname rxUiGet rxUiGet.simulationSigma <- function(x, ...) { @@ -255,7 +305,7 @@ rxUiGet.symengineModelPrune <- function(x, ...) { .tmp[[1]] <- quote(`rxModelVars`) .tmp <- eval(.tmp) .tmp <- rxode2(rxPrune(.tmp)) - .simulationModelAssignTOS(.x, .tmp) + .simulationModelAssignTOS(.x, .tmp) } attr(rxUiGet.symengineModelPrune, "desc") <- "symengine model with pruning if/else from UI" @@ -318,6 +368,51 @@ attr(rxUiGet.simulationIniModel, "desc") <- "simulation model with the ini value as.call(list(quote(`rxode2`), as.call(.ret))) } } +#' Filter out properties and adjust predDf +#' +#' @param predDf predDf from the ui model +#' @param lstExpr list of expressions for model or NULL, if NULL +#' defaults to the model expressions accessible by ui$lstExpr +#' @param ui original ui model or NULL +#' @return a list containing the adjusted predDf and lstExpr, or if +#' predDf is null simply the lstExpr +#' @noRd +#' @author Matthew L. Fidler +.rxFilterOutPropsAndAdjustPredDf <- function(ui, lstExpr, predDf=NULL) { + if (is.null(lstExpr)) { + .expr <- ui$lstExpr + } else { + .expr <- lstExpr + } + ## remove interpolation lines from .expr + .f <- vapply(seq_along(.expr), function(i) { + .e <- .expr[[i]] + if (is.call(.e)) { + identical(.e[[1]], quote(`linear`)) || + identical(.e[[1]], quote(`locf`)) || + identical(.e[[1]], quote(`nocb`)) || + identical(.e[[1]], quote(`midpoint`)) + } else { + FALSE + } + }, logical(1)) + .df <- data.frame(filter =.f, origLine=seq_along(.f)) + .predDf <- predDf + if (any(.df$filter)) { + .expr <- lapply(seq_along(.expr)[!.df$filter], function(i) { + .expr[[i]] + }) + .df <- .df[!.df$filter, , drop=FALSE] + .df$newLine <- seq_along(.df$filter) + if (!is.null(.predDf)) { + .predDf$line <- vapply(.predDf$line, function(i) { + .df$newLine[.df$origLine == i] + }, integer(1)) + } + } + if (is.null(.predDf)) return(.expr) + list(predDf=.predDf, lstExpr=.expr) +} #' Combine Error Lines and create rxode2 expression #' @@ -333,6 +428,9 @@ attr(rxUiGet.simulationIniModel, "desc") <- "simulation model with the ini value #' defaults to the model expressions accessible by #' `uiModel$lstExpr`. #' @param useIf Use an `if (CMT == X)` for endpoints +#' @param interpLines Interpolation lines, if not present +#' @param levelLines Levels lines for assigned strings. If not +#' present, use the interpolation lines from the current model. #' @return quoted expression that can be evaluated to compiled rxode2 #' model #' @export @@ -444,7 +542,8 @@ attr(rxUiGet.simulationIniModel, "desc") <- "simulation model with the ini value rxCombineErrorLines <- function(uiModel, errLines=NULL, prefixLines=NULL, paramsLine=NULL, modelVars=FALSE, cmtLines=TRUE, dvidLine=TRUE, lstExpr=NULL, - useIf=TRUE) { + useIf=TRUE, + interpLines=NULL, levelLines=NULL) { if(!inherits(uiModel, "rxUi")) { stop("uiModel must be a evaluated UI model by rxode2(modelFunction) or modelFunction()", call.=FALSE) @@ -468,16 +567,17 @@ rxCombineErrorLines <- function(uiModel, errLines=NULL, prefixLines=NULL, params length(errLines[[i]]) }, integer(1))) } - if (is.null(lstExpr)) { - .expr <- uiModel$lstExpr - } else { - .expr <- lstExpr - } .cmtLines <- NULL if (cmtLines) { .cmtLines <- uiModel$cmtLines } - .lenLines <- .lenLines + length(uiModel$lstExpr) - length(.predDf$line) + length(.cmtLines) + length(prefixLines) + .predDf <- uiModel$predDf + .tmp <- .rxFilterOutPropsAndAdjustPredDf(uiModel, predDf=.predDf, lstExpr=lstExpr) + .predDf <- .tmp$predDf + .expr <- .tmp$lstExpr + + .lenLines <- .lenLines + length(.expr) - + length(.predDf$line) + length(.cmtLines) + length(prefixLines) .k <- 2 + dvidLine * 1 if (is.null(paramsLine)) { @@ -485,6 +585,28 @@ rxCombineErrorLines <- function(uiModel, errLines=NULL, prefixLines=NULL, params .lenLines <- .lenLines - 1 .k <- 1 + dvidLine * 1 } + if (is.null(levelLines)) { + .levelLines <- rxUiGet.levels(list(uiModel)) + .lenLines <- .lenLines - length(.levelLines) + .k <- .k + length(.levelLines) + } else if (is.na(levelLines)) { + .levelLines <- list() + } else { + .levelLines <- levelLines + .lenLines <- .lenLines - length(.levelLines) + .k <- .k + length(.levelLines) + } + if (is.null(interpLines)) { + .interpLines <- rxUiGet.interpLines(list(uiModel)) + .lenLines <- .lenLines - length(.interpLines) + .k <- .k + length(.interpLines) + } else if (is.na(interpLines)) { + .interpLines <- list() + } else { + .interpLines <- interpLines + .lenLines <- .lenLines - length(.interpLines) + .k <- .k + length(.interpLines) + } .ret <- vector("list", .lenLines + .k) .curErrLine <- 1 .ret[[1]] <- quote(`{`) @@ -496,6 +618,18 @@ rxCombineErrorLines <- function(uiModel, errLines=NULL, prefixLines=NULL, params } else { .ret[[2]] <- paramsLine } + if (length(.levelLines) > 0) { + for (.i in seq_along(.levelLines)) { + .ret[[.k]] <- .levelLines[[.i]] + .k <- .k + 1 + } + } + if (length(.interpLines) > 0) { + for (.i in seq_along(.interpLines)) { + .ret[[.k]] <- .interpLines[[.i]] + .k <- .k + 1 + } + } for (.i in seq_along(prefixLines)) { .ret[[.k]] <- prefixLines[[.i]] .k <- .k + 1 diff --git a/R/err.R b/R/err.R index 00e61ad01..0ecd40d99 100644 --- a/R/err.R +++ b/R/err.R @@ -294,7 +294,7 @@ rxPreferredDistributionName <- function(dist) { #' rxDemoteAddErr() #' #' # This is used for logitNorm(NA), the additive portion is stripped -#' +#' #' @keywords internal rxDemoteAddErr <- function(errType) { if (inherits(errType, "factor")) { @@ -1035,6 +1035,74 @@ rxErrTypeCombine <- function(oldErrType, newErrType) { } } +#' Get a blank, theta1, or eta1 initialization block for iniDf +#' +#' @param type type of initialization block to return +#' @return A data.frame with the appropriate number/type of columns. +#' +#' For type="empty", the data.frame will have 0 rows but all the correct types. +#' +#' For type="theta", the data.frame will have 1 row with the correct +#' types and default values. The "name" and "est" will likely need to +#' be updated. +#' +#' For type="eta", the data.frame will have 1 row with the correct +#' types and default values for the a single eta being added. The +#' "name" and "est" will likely need to be updated. +#' +#' +#' @export +#' @author Matthew L. Fidler +#' @keywords internal +#' @examples +#' +#' .rxBlankIni("empty") +#' +#' .rxBlankIni("theta") +#' +#' .rxBlankIni("eta") +#' +.rxBlankIni <- function(type=c("empty", "theta", "eta")) { + type <- match.arg(type) + if (type == "empty") { + data.frame(ntheta=integer(0), + neta1=integer(0), + neta2=integer(0), + name=character(0), + lower=numeric(0), + est=numeric(0), + upper=numeric(0), + fix=logical(0), + err=character(0), + label=character(0), + stringsAsFactors=FALSE) + } else if (type == "theta") { + data.frame(ntheta=1L, + neta1=NA_integer_, + neta2=NA_integer_, + name=NA_character_, + lower=-Inf, + est=0, + upper=Inf, + fix=FALSE, + err=NA_character_, + label=NA_character_, + stringsAsFactors=FALSE) + } else { + data.frame(ntheta=NA_integer_, + neta1=1L, + neta2=1L, + name=NA_character_, + lower=0, + est=0.1, + upper=Inf, + fix=FALSE, + err=NA_character_, + label=NA_character_, + stringsAsFactors=FALSE) + } +} + #' Process the errors in the quoted expression #' #' @param x Quoted expression for parsing @@ -1077,10 +1145,24 @@ rxErrTypeCombine <- function(oldErrType, newErrType) { #' @noRd .errProcessExpression <- function(x, ini, linCmtSens = c("linCmtA", "linCmtB", "linCmtC"), - verbose=FALSE, checkMissing=TRUE) { + verbose=FALSE, checkMissing=TRUE, mv=rxUdfUiMv()) { + on.exit({ + .udfUiEnv$num <- 1L + .udfUiEnv$iniDf <- NULL + .udfUiEnv$lhs <- NULL + .udfUiEnv$parsing <- FALSE + }) + .udfUiEnv$parsing <- TRUE # ntheta neta1 neta2 name lower est upper fix err label # backTransform condition trLow trHi .env <- new.env(parent=emptyenv()) + .env$uiUseData <- FALSE + .env$uiUseMv <- FALSE + rxUdfUiEst(NULL) + rxUdfUiMv(mv) + .env$rxUdfUiCount <- new.env(parent=emptyenv()) + .env$before <- list() + .env$after <- list() .env$eta <- dimnames(ini)[[1]] .env$top <- TRUE if (!inherits(ini, "lotriFix") && inherits(ini, "matrix")) { @@ -1109,10 +1191,47 @@ rxErrTypeCombine <- function(oldErrType, newErrType) { .env$lstErr <- vector(length(.y), mode="list") .env$lstExpr <- vector(length(.y), mode="list") .env$hasErrors <- FALSE - for (.i in seq_along(.y)) { + .i <- 1L + .y <- lapply(seq_along(.y), function(i) { + .y[[i]] + }) + while(.i <= length(.y)) { .env$line <- .i if (identical(.y[[.i]][[1]], quote(`~`))) { .errHandleTilde(.y[[.i]], .env) + } else { + .env$redo <- FALSE + .cur <- .y[[.i]] + if (length(.cur) >= 3 && identical(.cur[[1]], quote(`<-`))) { + .env$lhs <- .cur[[2]] + } else if (length(.cur)>= 3 && identical(.cur[[1]], quote(`=`))) { + .env$lhs <- .cur[[2]] + } else { + .env$lhs <- NULL + } + .cur <- .handleUdfUi(.cur, .env) + .len <- length(.y) + .y <- c(lapply(seq_len(.i - 1), + function(i) { + .y[[i]] + }), .env$before, .cur, .env$after, + lapply(seq_len(.len - .i), + function(i) { + .y[[i + .i]] + })) + if (length(.y) != .len) { + # Update the lengths of lstChr, lstErr, lstExpr + .len <- length(.env$before) + length(.env$after) + .env$lstChr <- c(.env$lstChr, character(.len)) + .env$lstErr <- c(.env$lstErr, vector(.len, mode="list")) + .env$lstExpr <- c(.env$lstExpr, vector(.len, mode="list")) + .env$before <- list() + .env$after <- list() + # redo the parsing since the length of the expression has changed + next + } else if (.env$redo) { + next + } } .env$lstChr[[.i]] <- deparse1(.y[[.i]]) .env$lstExpr[[.i]] <- .y[[.i]] @@ -1121,6 +1240,7 @@ rxErrTypeCombine <- function(oldErrType, newErrType) { .env$err <- NULL .env$hasErrors <- TRUE } + .i <- .i + 1L } .env$iniDf <- .env$df if (is.null(.env$predDf)) { @@ -1169,6 +1289,16 @@ rxErrTypeCombine <- function(oldErrType, newErrType) { } else { .env$mv0 <- rxModelVars(paste(.env$lstChr, collapse="\n")) } + if (isTRUE(.env$uiUseMv) && is.null(mv)) { + # ui function requests model variables, so re-process + on.exit({ + rxUdfUiMv(NULL) + }) + return(.errProcessExpression(x=x, ini=ini, + linCmtSens = linCmtSens, + verbose=verbose, checkMissing=checkMissing, + mv=.env$mv0)) + } .env$errParams0 <- rxUiGet.errParams(list(.env, TRUE)) if (.Call(`_rxode2_isLinCmt`) == 1L) { .env$.linCmtM <- rxNorm(.env$mv0) @@ -1211,7 +1341,8 @@ rxErrTypeCombine <- function(oldErrType, newErrType) { "lastDistAssign", "line", "needsToBeAnErrorExpression", "needToDemoteAdditiveExpression", "top", "trLimit", ".numeric", "a", "b", "c", "d", "e", "f", "lambda", - "curCmt", "errGlobal", "linCmt", "ll", "distribution"), + "curCmt", "errGlobal", "linCmt", "ll", "distribution", "rxUdfUiCount", "before", "after", + "lhs"), ls(envir=.env, all.names=TRUE)) if (length(.rm) > 0) rm(list=.rm, envir=.env) if (checkMissing) .checkForMissingOrDupliacteInitials(.env) @@ -1303,4 +1434,3 @@ rxErrTypeCombine <- function(oldErrType, newErrType) { stop(paste(.env$err, collapse="\n"), call.=FALSE) } } - diff --git a/R/et.R b/R/et.R index f8ee9af85..f552a4a22 100644 --- a/R/et.R +++ b/R/et.R @@ -1376,11 +1376,13 @@ as.character.rxEvid <- function(x, ...) { as.rxEvid(NextMethod()) } +#' @rdname rxEvid +#' @param value It will be an error to set units for evid +#' @export `units<-.rxEvid` <- function(x, value) { stop("'evid' is unitless", call. = FALSE) } - #' @export `[<-.rxEvid` <- function(x, i, value) { as.rxEvid(NextMethod()) diff --git a/R/etTran.R b/R/etTran.R index d42c30ff4..3b4387739 100644 --- a/R/etTran.R +++ b/R/etTran.R @@ -23,29 +23,6 @@ .m$idxi } -.DTEnv <- NULL -.getDTEnv <- function() { - if (is.null(.DTEnv)) { - if (requireNamespace("data.table", quietly = TRUE)) { - .env <- loadNamespace("data.table") - if (utils::compareVersion( - as.character( - utils::packageVersion("data.table") - ), - "1.12.4" - ) >= 0) { - assignInMyNamespace(".DTEnv", .env) - return(.env) - } - } - .env <- new.env(parent = emptyenv()) - assignInMyNamespace(".DTEnv", .env) - return(.env) - } else { - return(.DTEnv) - } -} - .convertExtra <- function(dat) { d <- as.data.frame(dat) .colNames0 <- colnames(d) diff --git a/R/forder.R b/R/forder.R new file mode 100644 index 000000000..b3658d4c1 --- /dev/null +++ b/R/forder.R @@ -0,0 +1,69 @@ +.forderEnv <- new.env() +.forderEnv$useBase <- FALSE + + +.forder3 <- function(c1,c2,c3, decreasing=FALSE) { + data.table::data.table(c1=c1, + c2=c2, + c3=c3, + decreasing=decreasing, + na.last=TRUE)[order(c1, c2, c3), which=TRUE] +} + +.border3 <- function(c1,c2,c3, decreasing=FALSE) { + base::order(c1, c2, c3, decreasing=decreasing, na.last=NA, method="radix") +} + +.forder1 <- function(c1, decreasing=FALSE) { + data.table::data.table(c1=c1)[order(c1, decreasing=decreasing, na.last=TRUE), which=TRUE] +} + +.border1 <- function(c1, decreasing=FALSE) { + base::order(c1, na.last=NA, decreasing=decreasing, method="radix") +} + +.order1 <- function(c1, decreasing=FALSE) { + if (.forderEnv$useBase) { + .border1(c1, decreasing=decreasing) + } else { + .forder1(c1, decreasing=decreasing) + } +} + +.order3 <- function(c1,c2,c3, decreasing=FALSE) { + if (.forderEnv$useBase) { + .border3(c1,c2,c3, decreasing=decreasing) + } else { + .forder3(c1,c2,c3, decreasing=decreasing) + } +} +#' Force using base order for rxode2 radix sorting +#' +#' @param forceBase boolean indicating if rxode2 should use R's +#' [order()] for radix sorting instead of +#' `data.table`'s parallel radix sorting. +#' +#' @return value of `forceBase` (can change if `data.table` is not +#' available) +#' +#' @examples +#' \donttest{ +#' forderForceBase(TRUE) # Use base `order` for rxode2 sorts +#' forderForceBase(FALSE) # Use `data.table` for rxode2 sorts +#' } +#' @export +#' @keywords internal +forderForceBase <- function(forceBase = FALSE){ + if (forceBase) { + .forderEnv$useBase <- forceBase + } else if (requireNamespace("data.table", quietly = TRUE)) { + .forderEnv$useBase <- forceBase + } else { + .forderEnv$useBase <- TRUE + } + invisible(.forderEnv$useBase) +} + +.chin <- function(x, table) { + x %in% table +} diff --git a/R/getBaseSim.R b/R/getBaseSim.R index 468a43065..34fda7c3c 100644 --- a/R/getBaseSim.R +++ b/R/getBaseSim.R @@ -93,5 +93,9 @@ getBaseIniSimModel.default <- function(obj) { if (identical(.params, str2lang("params()"))) { .params <- NULL } - as.call(c(list(quote(`rxode2`)),as.call(c(list(quote(`{`)), .params, .sigma, .ini, .mod)))) + # now filter out the interpolation methods + .mod <- .rxFilterOutPropsAndAdjustPredDf(.ui, predDf=NULL, lstExpr=.mod) + .interp <- rxUiGet.interpLines(list(.ui)) + as.call(c(list(quote(`rxode2`)), + as.call(c(list(quote(`{`)), .params, .interp, .sigma, .ini, .mod)))) } diff --git a/R/linMod.R b/R/linMod.R new file mode 100644 index 000000000..ad0e1633b --- /dev/null +++ b/R/linMod.R @@ -0,0 +1,340 @@ +#' @export +rxUdfUi.linMod <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linMod, "nargs") <- 2L + +#' @export +rxUdfUi.linMod0 <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linMod0, "nargs") <- 2L + +#' @export +rxUdfUi.linModB <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModB, "nargs") <- 2L + +#' @export +rxUdfUi.linModB0 <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModB0, "nargs") <- 2L + +#' @export +rxUdfUi.linModA <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModA, "nargs") <- 2L + +#' @export +rxUdfUi.linModA0 <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModA0, "nargs") <- 2L + +#' @export +rxUdfUi.linModD <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModD, "nargs") <- 3L + +#' @export +rxUdfUi.linModD0 <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModD0, "nargs") <- 3L + +#' @export +rxUdfUi.linModM <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModM, "nargs") <- 2L + +#' @export +rxUdfUi.linModM0 <- function(fun) { + eval(fun) +} +attr(rxUdfUi.linModM0, "nargs") <- 2L + +#' @export +rxUdfUi.default <- function(fun) { + stop("rxode2 user defined function '", fun, "' not supported", call.=FALSE) # nocov +} + +#' Linear model to replace in rxode2 ui model +#' +#' @param variable The variable that the rxode2 will be made on. +#' +#' @param power The power of the polynomial that will be generated. +#' +#' @param intercept Boolean that tells if the intercept be generated. +#' +#' @param type the type of linear model replacement to be used. +#' +#' @param num the number the particular model is being generated. If +#' unspecified, query using `rxUdfUiNum()`. +#' +#' @param iniDf the initialization `data.frame`, if `NULL` query using +#' `rxUdfUiIniDf()` +#' +#' @param dv the dependent variable to use to generate the initial +#' estimates from the data. If `NULL` query using `rxUdfUiData()`. +#' +#' @param data logical that tells if the initial estimates of the +#' linear model should be estimated from the data. +#' +#' @param mv logical that tell if the model variables need to be used +#' to generate model variables. +#' +#' @param ... arguments that are passed to `linMod()` for the other +#' abbreviations of `linMod()` +#' +#' @return a list for use in when generating the `rxode2` ui model see +#' `rxUdfUi()` for details. +#' +#' @export +#' @family User functions +#' @author Matthew L. Fidler +#' @examples +#' +#' linMod(x, 3) +linMod <- function(variable, power, dv="dv", + intercept=TRUE,type=c("replace", "before", "after"), + num=NULL, iniDf=NULL, data=FALSE, mv=FALSE) { + .dv <- as.character(substitute(dv)) + .tmp <- suppressWarnings(try(force(dv), silent=TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .dv <- dv + } + } + .var <- as.character(substitute(variable)) + .tmp <- try(force(variable), silent=TRUE) + .doExp3 <- FALSE + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .var <- variable + } else if (!inherits(.tmp, "formula")) { + .dv <- as.character(substitute(dv)) + .tmp <- suppressWarnings(try(force(dv), silent=TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .dv <- dv + } + } + } else if (length(variable) == 2) { + if (!identical(variable[[1]], quote(`~`))) { + stop("unexpected formula, needs to be the form ~x^3", + call.=FALSE) + } + .doExp3 <- TRUE + .exp3 <- variable[[2]] + } else { + if (length(variable) != 3) { + stop("unexpected formula, needs to be the form dv~x^3", + call.=FALSE) + } + if (!identical(variable[[1]], quote(`~`))) { + stop("unexpected formula, needs to be the form dv~x^3", + call.=FALSE) + } + .dv <- as.character(variable[[2]]) + data <- TRUE + .exp3 <- variable[[3]] + .doExp3 <- TRUE + } + if (.doExp3) { + if (length(.exp3) == 1) { + .var <- variable <- as.character(.exp3) + power <- 1 + } else if (length(.exp3) == 3) { + if (!identical(.exp3[[1]], quote(`^`))) { + stop("unexpected formula, needs to be the form dv~x^3", + call.=FALSE) + } + if (!is.numeric(.exp3[[3]])) { + stop("unexpected formula, needs to be the form dv~x^3", + call.=FALSE) + } + .var <- variable <- as.character(.exp3[[2]]) + power <- .exp3[[3]] + } else { + stop("unexpected formula, needs to be the form dv~x^3", + call.=FALSE) + } + } + } + checkmate::assertCharacter(.var, len=1L, any.missing=FALSE, pattern = "^[.]*[a-zA-Z]+[a-zA-Z0-9._]*$", min.chars=1L, + .var.name="variable") + checkmate::assertCharacter(.dv, len=1L, any.missing=FALSE, pattern = "^[.]*[a-zA-Z]+[a-zA-Z0-9._]*$", min.chars=1L, + .var.name="dv") + checkmate::assertLogical(intercept, len=1L, any.missing=FALSE) + checkmate::assertIntegerish(power, lower=ifelse(intercept, 0L, 1L), len=1L) + if (is.null(num)) { + num <- rxUdfUiNum() + } + checkmate::assertIntegerish(num, lower=1, any.missing=FALSE, len=1) + if (mv && is.null(rxUdfUiMv())) { + if (intercept) { + return(list(replace=paste0("linModM(", .var, ", ", power, ")"), + uiUseMv=TRUE)) + } else { + return(list(replace=paste0("linModM0(", .var, ", ", power, ")"), + uiUseMv=TRUE)) + } + } + if (data && is.null(rxUdfUiData())) { + if (intercept) { + return(list(replace=paste0("linModD(", .var, ", ", power, ", ", .dv, ")"), + uiUseData=TRUE)) + } else { + return(list(replace=paste0("linModD0(", .var, ", ", power, ",", .dv, ")"), + uiUseData=TRUE)) + } + } + if (is.null(iniDf)) { + iniDf <- rxUdfUiIniDf() + } + assertIniDf(iniDf, null.ok=TRUE) + type <- match.arg(type) + .mv <- rxUdfUiMv() + if (!is.null(.mv)) { + .varsMv <- c(.mv$lhs, .mv$params, .mv$state) + .pre <- paste0(.var, num, rxIntToLetter(seq_len(power+ifelse(intercept, 1L, 0L))-1L)) + .pre <- vapply(.pre, function(v) { + if (v %in% .varsMv) { + paste0("rx.linMod.", v) + } else { + v + } + }, character(1), USE.NAMES=FALSE) + } else { + .pre <- paste0("rx.linMod.", .var, num, rxIntToLetter(seq_len(power+ifelse(intercept, 1L, 0L))-1L)) + } + + if (!is.null(iniDf)) { + .theta <- iniDf[!is.na(iniDf$ntheta),,drop=FALSE] + if (length(.theta$ntheta) > 0L) { + .maxTheta <- max(.theta$ntheta) + .theta1 <- .theta[1,] + } else { + .maxTheta <- 0L + .theta1 <- .rxBlankIni("theta") + } + .theta1$lower <- -Inf + .theta1$upper <- Inf + .theta1$fix <- FALSE + .theta1$label <- NA_character_ + .theta1$backTransform <- NA_character_ + .theta1$condition <- NA_character_ + .theta1$err <- NA_character_ + .est <- rep(0, length(.pre)) + if (data) { + .dat <- rxUdfUiData() + .wdv <- which(tolower(names(.dat)) == tolower(.dv)) + if (length(.wdv) == 0L) { + warning(.dv, "not found in data, so no initial estimates will be set to zero") + } else { + names(.dat)[.wdv] <- .dv + .model <- + stats::lm( + stats::as.formula( + paste0(.dv, " ~ stats::poly(", .var, ",", power, ")", + ifelse(intercept, "", "+0"))), + data=rxUdfUiData() + ) + .est <- coef(.model) + } + } + .cur <- c(list(.theta), + lapply(seq_along(.pre), function(i) { + .cur <- .theta1 + .cur$name <- .pre[i] + .cur$est <- .est[i] + .cur$ntheta <- .maxTheta+i + .cur + })) + .theta <- do.call(`rbind`, .cur) + .eta <- iniDf[is.na(iniDf$neta),,drop=FALSE] + .iniDf <- rbind(.theta, .eta) + } else { + .iniDf <- NULL + } + .linMod <- paste(vapply(seq_along(.pre), + function(i) { + if (intercept) { + if (i == 1) return(.pre[i]) + if (i == 2) return(paste0(.pre[i], "*", .var)) + paste0(.pre[i], "*", paste0(.var,"^", i-1L)) + } else { + if (i == 1) return(paste0(.pre[i], "*", .var)) + paste0(.pre[i], "*", paste0(.var,"^", i)) + } + }, character(1)), collapse="+") + if (type == "replace") { + list(replace=.linMod, + iniDf=.iniDf ) + } else if (type == "before") { + .replace <- paste0("rx.linMod.", .var, ".f", num) + list(before=paste0(.replace, " <- ", .linMod), + replace=.replace, + iniDf=.iniDf) + } else if (type == "after") { + .replace <- paste0("rx.linMod.", .var, ".f", num) + list(after=paste0(.replace, " <- ", .linMod), + replace="0", + iniDf=.iniDf) + } +} +#' @describeIn linMod linear model without intercept +#' @export +linMod0 <- function(...,intercept=FALSE) { + linMod(..., intercept=intercept) +} + +#' @describeIn linMod linear model before where it occurs +#' @export +linModB <- function(..., type="before") { + linMod(..., type=type) +} + +#' @describeIn linMod linear model before where the user function occurs +#' @export +linModB0 <- function(..., intercept=FALSE, type="before") { + linMod(..., intercept=intercept, type=type) +} +#' @describeIn linMod linear model after where the user function occurs +linModA <- function(..., type="after") { + linMod(..., type=type) +} + +#' @describeIn linMod liner model without an intercept placed after where the user function occurs +#' @export +linModA0 <- function(..., intercept=FALSE, type="after") { + linMod(..., intercept=intercept, type=type) +} + +#' @describeIn linMod linear model where initial estimates are generated from the data +#' @export +linModD <- function(..., intercept=TRUE, data=TRUE) { + linMod(..., intercept=intercept, data=data) +} + +#' @describeIn linMod linear model where initial estimates are generated from the data (no intercept) +#' @export +linModD0 <- function(..., intercept=FALSE, data=TRUE) { + linMod(..., intercept=intercept, data=data) +} + +#' @describeIn linMod linear model where the model variables are used to generate the model variables +#' @export +linModM <- function(..., intercept=TRUE, mv=TRUE) { + linMod(..., intercept=intercept, mv=mv) +} +#' @describeIn linMod linear model where the model variables are used to generate the model variables (no intercept) +#' @export +linModM0 <- function(..., intercept=FALSE, mv=TRUE) { + linMod(..., intercept=intercept, mv=mv) +} diff --git a/R/mu.R b/R/mu.R index d6550a513..57b36efba 100644 --- a/R/mu.R +++ b/R/mu.R @@ -212,7 +212,7 @@ .lhs <- deparse1(env$curLhs) if (any(.n == env$info$theta)) { return(.n) - } + } return(NULL) } else if (is.call(x)) { return(do.call(`c`, lapply(x[-1], .muRefExtractTheta, env=env))) @@ -260,7 +260,7 @@ #' @return A list of covariates with estimates attached #' #' @author Matthew Fidler -#' +#' #' @noRd .muRefExtractMultiplyMuCovariates <- function(x, doubleNames, env) { c(doubleNames, do.call(`c`, lapply(x, function(y) { @@ -708,7 +708,8 @@ #' @author Matthew L. Fidler #' @noRd .rxMuRefHandleNonPlusCall <- function(x, env) { - assign(".curEval", as.character(x[[1]]), env) + .curEval <- as.character(x[[1]]) + assign(".curEval", .curEval, env) env$curHi <- NA_real_ env$curLow <- NA_real_ if (env$.curEval == "probitInv" || @@ -935,7 +936,7 @@ .est, ") needs to be below ", .range[2])) } if (.lower < .range[1]) { - if (rxode2.verbose.pipe && is.finite(.lower)) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE)) && is.finite(.lower)) { .minfo(paste0("'", .name, "' lower bound (", .lower, ") needs to be equal or above ", .range[1], "; adjusting")) @@ -943,7 +944,7 @@ .lower <- .range[1] } if (.upper > .range[2]) { - if (rxode2.verbose.pipe && is.finite(.upper)) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE)) && is.finite(.upper)) { .minfo(paste0("'", .name, "' upper bound (", .upper, ") needs to be equal or below ", .range[2], "; adjusting")) diff --git a/R/nearpd.R b/R/nearpd.R deleted file mode 100644 index 1b2eb5c4e..000000000 --- a/R/nearpd.R +++ /dev/null @@ -1,5 +0,0 @@ -.nearPD <- function(mat) { - .ret <- try(Matrix::nearPD(mat), silent=TRUE) - if (inherits(.ret, "try-error")) return(NULL) - as.matrix(.ret$mat) -} diff --git a/R/piping-ini.R b/R/piping-ini.R index b9b8a0744..05c170852 100644 --- a/R/piping-ini.R +++ b/R/piping-ini.R @@ -1,3 +1,11 @@ +#' Message about fixing or unfixing a parameter +#' +#' @param ini this is the iniDf data frame +#' @param w this indicates the row number of the item that is fixed or +#' unfixed +#' @param fixedValue this is a boolean +#' @noRd +#' @author Matthew L. Fidler .msgFix<- function(ini, w, fixedValue) { lapply(w, function(.w) { if (ini$fix[.w] != fixedValue) { @@ -10,8 +18,20 @@ }) } +#' This modifies the iniDf to fix (or unfix) parameters and related +#' values +#' +#' Note that the block of etas will be fixed/unfixed when a single +#' value is fixed/unfixed +#' +#' @param ini iniDf data.frame +#' @param w which item will be fixed +#' @param fixedValue should this be fixed `TRUE` or unfixed `FALSE` +#' @return nothing, called for side effects +#' @noRd +#' @author Matthew L. Fidler .iniModifyFixedForThetaOrEtablock <- function(ini, w, fixedValue) { - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .msgFix(ini, w, fixedValue) } ini$fix[w] <- fixedValue @@ -22,7 +42,7 @@ while (length(.etas) > 0) { .neta <- .etas[1] w <- which(ini$neta1 == .neta | ini$neta2 == .neta) - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .msgFix(ini, w, fixedValue) } ini$fix[w] <- fixedValue @@ -70,20 +90,20 @@ if (is.null(rhs)) { } else if (length(rhs) == 1) { ini$est[.w] <- rhs - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("change initial estimate of {.code ", ini$name[.w], "} to {.code ", ini$est[.w], "}")) } .lower <- ini$lower[.w] .upper <- ini$upper[.w] if (.lower >= rhs) { ini$lower[.w] <- -Inf - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("lower bound of {.code ", ini$name[.w], "} reset to {.code -Inf}")) } } if (.upper <= rhs) { ini$upper[.w] <- Inf - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("upper bound of {.code ", ini$name[.w], "} reset to {.code Inf}")) } } @@ -94,14 +114,14 @@ } else if (length(rhs) == 2) { ini$lower[.w] <- rhs[1] ini$est[.w] <- rhs[2] - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("change initial estimate (", ini$est[.w], ") and lower bound (", ini$lower[.w], ") of {.code ", ini$name[.w], "}")) } # now check/change upper if needed .upper <- ini$upper[.w] if (.upper <= rhs[1] || .upper <= rhs[2]) { ini$upper[.w] <- Inf - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("upper bound for initial estimate (", ini$name[.w], ") reset to Inf")) } } @@ -109,7 +129,7 @@ ini$lower[.w] <- rhs[1] ini$est[.w] <- rhs[2] ini$upper[.w] <- rhs[3] - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("change initial estimate (", ini$est[.w], ") and upper/lower bound (", ini$lower[.w], " to ", ini$upper[.w], ") of {.code ", ini$name[.w], "}")) } } @@ -209,15 +229,15 @@ name=paste0("(", neta2, ",", neta1, ")"), lower= -Inf, est=est, upper=Inf, fix=.fix, label=NA_character_, backTransform=NA_character_, condition="id", err=NA_character_) - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("add covariance between {.code ", ini$name[.w1], "} and {.code ", ini$name[.w2], "} with initial estimate {.code ", est, "}")) } rbind(ini,.ini2) } -#' This function handles the lotri process and integrates into current UI +#' This function handles the lotri process and integrates into current UI #' -#' This will update the matrix and integrate the initial estimates in the UI +#' This will update the matrix and integrate the initial estimates in the UI #' #' @param mat Lotri processed matrix from the piping ini function #' @@ -257,7 +277,7 @@ } } } - if (rxode2.verbose.pipe && .drop) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE)) && .drop) { .minfo(paste0("some correlations may have been dropped for the variables: {.code ", paste(.dn, collapse="}, {.code "), "}")) .minfo("the piping should specify the needed covariances directly") } @@ -428,7 +448,6 @@ # This likely cannot be reached because all scenarios should be handled # above in the input checking. The line remains in the code defensively. stop("Cannot find parameter '", append, "'", call.=FALSE) # nocov - } else if (appendClean == wLhs) { warning("parameter '", lhs, "' set to be moved after itself, no change in order made", call. = FALSE) @@ -588,6 +607,17 @@ #' @keywords internal #' @export .iniHandleLine <- function(expr, rxui, envir=parent.frame(), append = NULL) { + if (.matchesLangTemplate(expr, str2lang("~diag()"))) { + .iniHandleDiag(expr=NULL, rxui=rxui) + return(invisible()) + } else if (length(expr) == 2L && + identical(expr[[1]], quote(`~`)) && + is.call(expr[[2]]) && length(expr[[2]]) >= 2L && + identical(expr[[2]][[1]], quote(`diag`))) { + # .matchesLangTemplate(expr, str2lang("~diag(.)")) doesn't work + .iniHandleDiag(expr=expr, rxui=rxui) + return(invisible()) + } # Convert all variations on fix, fixed, FIX, FIXED; unfix, unfixed, UNFIX, # UNFIXED to fix and unfix to simplify all downstream operations expr <- .iniSimplifyFixUnfix(expr) @@ -595,19 +625,28 @@ # downstream operations expr <- .iniSimplifyAssignArrow(expr) - if (.matchesLangTemplate(expr, str2lang(".name <- NULL"))) { - expr <- as.call(list(quote(`-`), expr[[2]])) - } else if (.matchesLangTemplate(expr, str2lang(".name ~ NULL"))) { + if (.matchesLangTemplate(expr, str2lang(".name <- NULL")) || + .matchesLangTemplate(expr, str2lang(".name ~ NULL")) || + .matchesLangTemplate(expr, str2lang("cov(.name, .name) <- NULL")) || + .matchesLangTemplate(expr, str2lang("cor(.name, .name) <- NULL")) || + .matchesLangTemplate(expr, str2lang("cov(.name, .name) ~ NULL")) || + .matchesLangTemplate(expr, str2lang("cor(.name, .name) ~ NULL"))) { expr <- as.call(list(quote(`-`), expr[[2]])) } + # now handle dropping covariances + if (.matchesLangTemplate(expr, str2lang("-cov(.name, .name)")) || + .matchesLangTemplate(expr, str2lang("-cor(.name, .name)"))) { + .iniHandleRmCov(expr=expr, rxui=rxui) + return(invisible()) + } + # Convert fix(name) or unfix(name) to name <- fix or name <- unfix if (.matchesLangTemplate(expr, str2lang("fix(.name)"))) { expr <- as.call(list(quote(`<-`), expr[[2]], quote(`fix`))) } else if (.matchesLangTemplate(expr, str2lang("unfix(.name)"))) { expr <- as.call(list(quote(`<-`), expr[[2]], quote(`unfix`))) } - if (.matchesLangTemplate(expr, str2lang(".name <- label(.)"))) { .iniHandleLabel(expr=expr, rxui=rxui, envir=envir) } else if (.matchesLangTemplate(expr, str2lang(".name <- backTransform(.)"))) { @@ -892,3 +931,111 @@ zeroRe <- function(object, which = c("omega", "sigma"), fix = TRUE) { ini(.ret) <- iniDf .ret } + +#' This removes the off-diagonal BSV from a rxode2 iniDf +#' +#' @param ui rxode2 ui model +#' +#' @param diag character vector of diagonal values to remove +#' +#' @return iniDf with modified diagonal +#' @noRd +#' @author Matthew L. Fidler +.iniDfRmDiag <- function(iniDf, diag=character(0)) { + .iniDf <- iniDf + .theta <- .iniDf[!is.na(.iniDf$ntheta),,drop=FALSE] + .eta <- .iniDf[is.na(.iniDf$ntheta),,drop=FALSE] + if (length(diag) == 0) { + .w <- which(.eta$neta1 == .eta$neta2) + .rmNames <- .eta[-.w, "name"] + .eta <- .eta[.w,, drop=FALSE] + .iniDf <- rbind(.theta, .eta) + } else { + .rmNames <- character(0) + for (.e in diag) { + .w <- which(.eta$name == .e) + if (length(.w) == 1L) { + .n <- .eta$neta1[.w] + .w <- vapply(seq_along(.eta$neta1), + function(i) { + if (.eta$neta1[i] == .eta$neta2[i]) { + TRUE + } else if (.eta$neta1[i] == .n && .eta$neta2[i] != .n) { + FALSE + } else if (.eta$neta2[i] == .n && .eta$neta1[i] != .n) { + FALSE + } else { + TRUE + } + }, logical(1), USE.NAMES = TRUE) + .rmNames <- c(.rmNames, .eta$name[!.w]) + .eta <- .eta[.w,,drop=FALSE] + } else { + stop("cannot find parameter '", .e, "' for covariance removal", call.=FALSE) + } + } + .mat <- lotri::as.lotri(.eta) + .mat <- lotri::rcm(.mat) + class(.mat) <- c("lotriFix", class(.mat)) + .eta <- as.data.frame(.mat) + .eta$err <- NA_character_ + .iniDf <- rbind(.theta, .eta) + } + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { + for (.v in .rmNames) { + .minfo(paste0("remove covariance {.code ", .v, "}")) + } + } + .iniDf +} + +.iniHandleRmCov <- function(expr, rxui) { + .iniDf <- rxui$iniDf + .theta <- .iniDf[!is.na(.iniDf$ntheta),, drop = FALSE] + .eta <- .iniDf[is.na(.iniDf$ntheta),, drop = FALSE] + .mat <- lotri::as.lotri(.eta) + .n1 <- as.character(expr[[2]][[2]]) + .v1 <- which(.n1==dimnames(.mat)[[1]]) + if (length(.v1) != 1) { + stop("cannot find parameter '", .n1, "' for covariance removal", call.=FALSE) + } + .n2 <- as.character(expr[[2]][[3]]) + .v2 <- which(.n2==dimnames(.mat)[[1]]) + if (length(.v2) != 1) { + stop("cannot find parameter '", .n2, "' for covariance removal", call.=FALSE) + } + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { + .minfo(paste0("remove covariance {.code (", .n1, ", ", .n2, ")}")) + } + + .mat[.v1, .v2] <- .mat[.v2, .v1] <- 0 + .mat <- lotri::rcm(.mat) + class(.mat) <- c("lotriFix", class(.mat)) + .eta <- as.data.frame(.mat) + .eta$err <- NA_character_ + .iniDf <- rbind(.theta, .eta) + assign("iniDf", .iniDf, envir=rxui) +} + +.iniHandleDiag <- function(expr, rxui){ + if (is.null(expr)) { + assign("iniDf", .iniDfRmDiag(rxui$iniDf), envir=rxui) + } else { + # now get the variables in the diag expression + .env <- new.env(parent=emptyenv()) + .env$names <- character(0) + .f <- function(x) { + if (is.name(x)) { + .env$names <- c(.env$names, as.character(x)) + } else if (is.call(x)) { + lapply(lapply(seq_along(x)[-1], function(i) {x[[i]]}), .f) + } + } + expr <- expr[[2]] + lapply(seq_along(expr)[-1], + function(i) { + .f(expr[[i]]) + }) + assign("iniDf", .iniDfRmDiag(rxui$iniDf, .env$names), envir=rxui) + } +} diff --git a/R/piping-model.R b/R/piping-model.R index 2ecf21bbd..4b33430b7 100644 --- a/R/piping-model.R +++ b/R/piping-model.R @@ -185,7 +185,7 @@ model.rxModelVars <- model.rxode2 .isErr <- x %in% .v$err if (auto || .isErr) { .addVariableToIniDf(x, rxui, promote=ifelse(.isErr, NA, FALSE)) - } else if (rxode2.verbose.pipe) { + } else if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("add covariate {.code ", x, "}")) } }) @@ -750,10 +750,10 @@ attr(rxUiGet.errParams, "desc") <- "Get the error-associated variables" if (length(.w1) > 0) .iniDf <- .iniDf[-.w1, ] .w1 <- which(.iniDf$neta2 == .neta) if (length(.w1) > 0) .iniDf <- .iniDf[-.w1, ] - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .mwarn(paste0("remove between subject variability {.code ", var, "}")) } - } else if (rxode2.verbose.pipe) { + } else if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { if (is.na(promote)) { .mwarn(paste0("remove residual parameter {.code ", var, "}")) } else { @@ -912,7 +912,7 @@ rxSetCovariateNamesForPiping <- function(covariates=NULL) { } if (!is.null(.varSelect$cov)) { if (var %in% .varSelect$cov) { - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("add covariate {.code ", var, "} (as requested by cov option)")) } return(invisible()) @@ -963,7 +963,7 @@ rxSetCovariateNamesForPiping <- function(covariates=NULL) { .extra$neta2 <- .eta .extra$name <- var .extra$condition <- "id" - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { if (is.na(promote)) { } else if (promote) { if (is.na(value)) { @@ -985,14 +985,14 @@ rxSetCovariateNamesForPiping <- function(covariates=NULL) { } else if (!promote) { if (regexpr(.varSelect$covariateExceptions, tolower(var)) != -1 || regexpr(.varSelect$thetaModelReg, var, perl=TRUE) == -1) { - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("add covariate {.code ", var, "}")) } return(invisible()) } if (!is.null(.varSelect$covariateNames)) { if (var %in% .varSelect$covariateNames) { - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { .minfo(paste0("add covariate {.code ", var, "} (known covariate)")) } return(invisible()) @@ -1008,7 +1008,7 @@ rxSetCovariateNamesForPiping <- function(covariates=NULL) { .extra$est <- value .extra$ntheta <- .theta .extra$name <- var - if (rxode2.verbose.pipe) { + if (isTRUE(getOption("rxode2.verbose.pipe", TRUE))) { if (is.na(promote)) { .minfo(paste0("add residual parameter {.code ", var, "} and set estimate to {.number ", value, "}")) } else if (promote) { diff --git a/R/piping.R b/R/piping.R index 798d732e4..93a4c3101 100644 --- a/R/piping.R +++ b/R/piping.R @@ -202,10 +202,7 @@ }) } else if (inherits(.cur, "matrix")) { .cur2 <- .cur - if (!inherits(.cur, "lotriFix")) { - class(.cur2) <- c("lotriFix", class(.cur)) - } - .unlistedBrackets <- as.list(as.expression(.cur2)[[-1]])[-1] + .unlistedBrackets <- as.list(lotri::lotriAsExpression(.cur2, plusNames=TRUE)[[-1]])[-1] } else if (inherits(.cur, "character") && !is.null(names(.cur))) { .unlistedBrackets <- lapply(paste(names(.cur),"=", setNames(.cur, NULL)), str2lang) @@ -238,8 +235,96 @@ .expandedForm } -.nsEnv <- new.env(parent=emptyenv()) +#' This function collapses the lotri line form to the plus form +#' +#' @param expressionList Expression list that is input to change into +#' matrix expression form the new line expressions to the classic +#' plus expressions. +#' @return expression list where lotri line for covariance matrices +#' are translated to classic plus form. +#' @author Matthew L. Fidler +#' @noRd +#' @examples +#' +#' tmp <- list(str2lang("d ~ 1"), +#' str2lang("e ~ c(0.5, 3)"), +#' str2lang("cp ~ add(add.sd)"), +#' str2lang("cp ~ add(add.sd) + prop(prop.sd)"), +#' str2lang("cp ~ + add(add.sd)")) +#' +#' .collapseLotriLineFormToPlusForm(tmp) +#' +.collapseLotriLineFormToPlusForm <- function(expressionList) { + .env <- new.env(parent=emptyenv()) + .env$ret <- expressionList + .env$lst <- list() + .env$last <- NA_integer_ + + .f <- function() { + if (!is.na(.env$last)) { + .val <- as.call(c(list(quote(`{`)), .env$lst)) + .val <- as.call(c(str2lang("lotri::lotri"), .val)) + .val <- suppressMessages(try(eval(.val), silent=TRUE)) + if (inherits(.val, "try-error")) { + for (.j in seq_along(.env$lst)) { + .env$ret[[.env$last + .j - 1L]] <- .env$lst[[.j]] + } + } else { + .val <- lotri::lotriAsExpression(.val, plusNames=TRUE) + .val <- lapply(seq_along(.val)[-1], + function(i){ + .val[[i]] + })[[1]] + .val <- lapply(seq_along(.val)[-1], + function(i){ + .val[[i]] + }) + for (.j in seq_along(.val)) { + .env$ret[[.env$last + .j - 1L]] <- .val[[.j]] + } + } + .env$lst <- list() + .env$last <- NA_integer_ + } + } + for (.i in seq_along(.env$ret)) { + .cur <- .env$ret[[.i]] + if (is.call(.cur) && identical(.cur[[1]], quote(`~`)) && + length(.cur) == 3L && + length(.cur[[2]]) == 1L # excludes ll(cp) ~ 1 + ) { + .isLotri <- TRUE + # Check to see if this is an error call + if (is.call(.cur[[3]])) { + .call <- deparse1(.cur[[3]][[1]]) + if (.call == "+" && + length(.cur[[3]]) >= 2 && + is.call(.cur[[3]][[2]])) { + .call <- deparse1(.cur[[3]][[2]][[1]]) + } + if (.call %in% names(.errDist)) { + .isLotri <- FALSE + } + } + if (.isLotri) { + if (is.na(.env$last)) { + .env$last <- .i + } + .env$ret[[.i]] <- NA + .env$lst <- c(.env$lst, .cur) + } + } else { + .f() + } + } + .f() + .w <- which(vapply(seq_along(.env$ret), function(i) { + !(length(.env$ret[[i]]) == 1L && is.na(.env$ret[[i]])) + }, logical(1), USE.NAMES=FALSE)) + lapply(.w, function(i) { .env$ret[[i]]}) +} +.nsEnv <- new.env(parent=emptyenv()) .nsEnv$.quoteCallInfoLinesAppend <- NULL #' Returns quoted call information @@ -289,8 +374,18 @@ warning("empty argument ignored") return(NULL) } else if (length(.quoted) == 1) { - .bracket[i] <- TRUE - assign(".bracket", .bracket, envir=.env) + if (identical(.quoted, quote(`diag`)) || + (is.call(.quoted) && identical(.quoted[[1]], quote(`diag`)))) { + .quoted <- str2lang("~diag()") + } else { + .bracket[i] <- TRUE + assign(".bracket", .bracket, envir=.env) + } + } else if (length(.quoted) >= 1 && + identical(.quoted[[1]], quote(`diag`))) { + .quoted <- as.call(c(list(quote(`~`)), .quoted)) + } else if (identical(.quoted[[1]], quote(`diag`))) { + } else if (identical(.quoted[[1]], quote(`{`)) || identical(.quoted[[1]], quote(`c`)) || identical(.quoted[[1]], quote(`list`))) { @@ -299,7 +394,7 @@ } else if (identical(.quoted[[1]], quote(`as.formula`))) { .quoted <- .quoted[[2]] } else if (identical(.quoted[[1]], quote(`~`))) { - if (length(.quoted) == 3L) { + if (length(.quoted) == 3L && !is.null(.quoted[[3]])) { .quoted[[3]] <- .iniSimplifyFixUnfix(.quoted[[3]]) if (identical(.quoted[[3]], quote(`fix`)) || identical(.quoted[[3]], quote(`unfix`))) { @@ -329,8 +424,7 @@ } .ret[[i]] }) - - .ret[vapply(seq_along(.ret), function(i) { + .collapseLotriLineFormToPlusForm(.ret[vapply(seq_along(.ret), function(i) { !is.null(.ret[[i]]) - }, logical(1), USE.NAMES=FALSE)] + }, logical(1), USE.NAMES=FALSE)]) } diff --git a/R/rudf.R b/R/rudf.R index f81eea23d..0a0dcae12 100644 --- a/R/rudf.R +++ b/R/rudf.R @@ -203,7 +203,6 @@ rxRmFunParse <- function(name) { .udfEnv$envir <- env[[1]] } else { .udfEnv$envir <- env - } } .udfAddToSearch(env) @@ -291,6 +290,20 @@ rxRmFunParse <- function(name) { #' @noRd #' @author Matthew L. Fidler .getUdfInfo <- function(fun, nargs) { + .nargs <- .rxUdfUiNarg(fun) + if (is.integer(.nargs) && !is.na(.nargs)) { + if (.nargs > 0L && nargs != .nargs) { + return(list(nargs=NA_integer_, + sprintf("rxode2 ui user defined R function has %d arguments, but supplied %d", + .nargs, nargs))) + } else if (.nargs <= 0L) { + return(list(nargs=NA_integer_, + "rxode2 ui user defined R needs to be setup with a positive number of arguments")) + } else { + return(list(nargs=-42L, + ".rxUiUdfNone")) + } + } if (is.null(.udfEnv$envir)) { return(list(nargs=NA_integer_, "rxode2 cannot determine which environment the user defined functions are located")) diff --git a/R/rudfui.R b/R/rudfui.R new file mode 100644 index 000000000..52b576a56 --- /dev/null +++ b/R/rudfui.R @@ -0,0 +1,374 @@ +.udfUiEnv <- new.env(parent=emptyenv()) + +#' Reset the rxode2 ui environment variables +#' +#' @return NULL silently +#' @export +#' +#' @keywords internal +#' @author Matthew L. Fidler +#' @examples +#' rxUdfUiReset() +rxUdfUiReset <- function() { + .udfUiEnv$num <- 1L + .udfUiEnv$iniDf <- NULL + .udfUiEnv$lhs <- NULL + .udfUiEnv$data <- NULL + .udfUiEnv$est <- NULL + .udfUiEnv$parsing <- FALSE + .udfUiEnv$mv <- NULL + invisible(NULL) +} + +rxUdfUiReset() + + +#' This gives the current number in the ui of the particular function being called. +#' +#' If this is called outside of function parsing or the input is +#' unexpected this returns 1L. This is useful when writing replacement +#' UI functions +#' +#' @return integer greater than 1L +#' @family User functions +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' rxUdfUiNum() +rxUdfUiNum <- function() { + if (checkmate::testIntegerish(.udfUiEnv$num, lower=1L, len=1L, any.missing=FALSE)) { + as.integer(.udfUiEnv$num) + } else { + 1L + } +} + +#' Get the rxode2 iniDf of the current UI being processed (or return NULL) +#' +#' @return Initial `data.frame` being processed or `NULL` for nothing. +#' +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' rxUdfUiIniDf() +#' +rxUdfUiIniDf <- function() { + if (testIniDf(.udfUiEnv$iniDf)) { + .udfUiEnv$iniDf + } else { + NULL + } +} +#' Return the lhs parsed language expression +#' +#' @return lhs language expression or NULL +#' @family User functions +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' rxUdfUiIniLhs() +#' +rxUdfUiIniLhs <- function() { + if (is.language(.udfUiEnv$lhs)) { + .udfUiEnv$lhs + } else { + NULL + } +} + +#' Return the model variables that is being processed or setup model +#' variables for processing +#' +#' +#' @param value when specified, this assigns the model variables to be +#' processed, or resets it by assigning it to be `NULL`. +#' +#' @return value of the `modelVariables` being processed or `NULL`. +#' +#' @family User functions +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' rxUdfUiMv() +#' +rxUdfUiMv <- function(value) { + if (missing(value)) { + .udfUiEnv$mv + } else if (inherits(value, "rxModelVars")) { + .udfUiEnv$mv <- value + } else if (is.null(value)) { + .udfUiEnv$mv <- value + } else { + stop("rxUdfUiMt must be called with model variables, NULL, or without any arguments", + call.=FALSE) + } +} +#' Return the data.frame that is being processed or setup data.frame for processing +#' +#' +#' @param value when specified, this assigns the data.frame to be processed, or resets it by assigning it to be `NULL`. +#' +#' @return value of the `data.frame` being processed or `NULL`. +#' +#' @export +#' @family User functions +#' @author Matthew L. Fidler +#' @examples +#' +#' rxUdfUiData() +#' +rxUdfUiData <- function(value) { + if (missing(value)) { + .udfUiEnv$data + } else if (is.data.frame(value)) { + .udfUiEnv$data <- value + } else if (is.null(value)) { + .udfUiEnv$data <- value + } else { + stop("rxUdfUiData must be called with a data.frame, NULL, or without any arguments", + call.=FALSE) + } +} +#' Return the current estimation method for the UI processing +#' +#' @param value when specified, this assigns the character value of +#' the estimation method or NULL if there is nothing being estimated +#' @return value of the estimation method being processed or NULL +#' @family User functions +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' rxUdfUiEst() +#' +rxUdfUiEst <- function(value) { + if (missing(value)) { + .udfUiEnv$est + } else if (checkmate::testCharacter(value, min.chars=1L, any.missing=FALSE, len=1L)) { + .udfUiEnv$est <- value + } else if (is.null(value)) { + .udfUiEnv$est <- value + } else { + stop("rxUdfUiEst must be called with a character, NULL, or without any arguments", + call.=FALSE) + } +} +#' Returns if the current ui function is being parsed +#' +#' @return logical if the current ui function is being parsed +#' @family User functions +#' @export +#' @author Matthew L. Fidler +#' @examples +#' rxUdfUiParsing() +rxUdfUiParsing <- function() { + .udfUiEnv$parsing +} + + +#' Handle User-Defined Functions in UI +#' +#' This function processes expressions to handle user-defined +#' functions in the UI. It will see if there is any registered `s3` +#' generic in `rxUdfUi` and call that with the parsed function. The +#' s3 generic is responsible for returning a list in the correct form +#' so that the parsed UI will be updated. +#' +#' @param expr The expression to be processed. +#' @param env The environment in which to evaluate the expression. +#' @return The processed expression. +#' @noRd +.handleUdfUi <- function(expr, env) { + if (is.call(expr)) { + if (length(expr) == 1L) { + return(expr) + } + .c <- as.character(expr[[1]]) + .fun <- try(utils::getS3method("rxUdfUi", .c), silent=TRUE) + if (inherits(.fun, "try-error")) { + as.call(c(expr[[1]], lapply(expr[-1], .handleUdfUi, env=env))) + } else { + if (!exists(.c, envir=env$rxUdfUiCount)) { + assign(.c, 0L, envir=env$rxUdfUiCount) + } + .num <- get(.c, envir=env$rxUdfUiCount) + 1L + assign(.c, .num, envir=env$rxUdfUiCount) + .udfUiEnv$num <- .num + .udfUiEnv$iniDf <- env$df + .udfUiEnv$lhs <- env$lhs + .e <- .fun(expr) + if (is.language(.e$replace)) { + if (!identical(expr, .e$replace)) { + env$redo <- TRUE + } + expr <- .e$replace + } else if (length(.e$replace) == 1 && + inherits(.e$replace, "character")) { + .t <- try(str2lang(.e$replace), silent=TRUE) + if (inherits(.t, "try-error")) { + stop("rxode2 ui user function '", .c, "' failed to produce code that could be parsed '", .e$replace, "'", + call.=FALSE) + } + if (!identical(expr, .t)) { + env$redo <- TRUE + } + expr <- .t + } else { + stop("rxode2 ui user function '", .c, "' failed to produce code that could be parsed in the", + call.=FALSE) + } + .handleUdifUiBeforeOrAfter("before", .e, env, .c) + .handleUdifUiBeforeOrAfter("after", .e, env, .c) + if (inherits(.e$iniDf, "data.frame")) { + env$df <- .e$iniDf + } + if (is.null(.udfUiEnv$data) && + checkmate::testLogical(.e$uiUseData, len=1L, any.missing=FALSE)) { + env$uiUseData <- .e$uiUseData + } + if (is.null(.udfUiEnv$mv) && + checkmate::testLogical(.e$uiUseMv, len=1L, any.missing=FALSE)) { + env$uiUseMv <- .e$uiUseMv + } + if (!is.call(expr)) return(expr) + expr <- as.call(c(expr[[1]], lapply(expr[-1], .handleUdfUi, env=env))) + if (is.call(expr) && length(expr) >= 2L && + (identical(expr[[1]], quote(`+`)) || + identical(expr[[1]], quote(`-`)) || + identical(expr[[1]], quote(`^`)) || + identical(expr[[1]], quote(`/`)) || + identical(expr[[1]], quote(`*`)))) { + expr <- str2lang(paste0("(", deparse1(expr), ")")) + } + expr + } + } else { + expr + } +} + +#' This function is called when processing rxode2 user functions from +#' the models +#' +#' +#' @param fun this is the function that needs to be parsed and +#' changed. This is a R language expression +#' +#' @return This needs to return a list with the following elements: +#' +#' - `iniDf` -- the modified initial estimate data.frame +#' +#' - `before` -- any model code that needs to be added before the current line +#' +#' - `after` -- any model code that needs to be added after the current line +#' +#' - `replace` -- replacement code for this user function +#' +#' @export +#' @keywords internal +#' @author Matthew L. Fidler +rxUdfUi <- function(fun) { + UseMethod("rxUdfUi") +} + +#' Get the number of arguments for user defined functions for ui +#' replacement +#' +#' @param fun The rxode2 ui function to replace +#' @return The number of arguments needed for this function +#' @noRd +#' @author Matthew L. Fidler +.rxUdfUiNarg <- function(fun) { + .cls <- try(utils::getS3method("rxUdfUi", fun), silent=TRUE) + if (inherits(.cls, "try-error")) { + return(NA_integer_) + } + .nargs <- attr(.cls, "nargs") + if (is.null(.nargs)) { + return(NA_integer_) + } + as.integer(.nargs) +} + +#' Convert a positive integer to a letter series +#' +#' @param x integer to convert +#' @param base can be 2 to 26 +#' @return a sequence of letters representing the number(s) input +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' rxIntToLetter(1:100) +#' +rxIntToLetter <- function(x, base=26L) { + checkmate::testIntegerish(x, lower=0L, any.missing=FALSE) + checkmate::testIntegerish(base, lower=2L, upper=26L, any.missing=FALSE, len=1L) + .Call(`_rxode2_itoletter`, as.integer(x), as.integer(base), PACKAGE="rxode2") +} + +#' Convert a positive base +#' +#' @param x integer to convert +#' @param base can be 2 to 36 +#' @return a sequence of letters and representing the number(s) input +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' rxIntToBase(1:100) +#' +rxIntToBase <- function(x, base=36L) { + checkmate::testIntegerish(x, lower=0L, any.missing=FALSE) + checkmate::testIntegerish(base, lower=2L, upper=36L, any.missing=FALSE, len=1L) + .Call(`_rxode2_itostr`, as.integer(x), as.integer(base), PACKAGE="rxode2") +} + +.handleUdifUiBeforeOrAfter <- function(type="before", e, env, fun) { + .cur <- e[[type]] + if (is.null(.cur)) return(invisible()) + if (is.list(.cur)) { + .ret <- lapply(seq_along(.cur), + function(i) { + if (is.language(.cur[[i]])) { + .cur[[i]] + } else if (length(.cur[[i]]) == 1L && + inherits(.cur[[i]], "character")) { + .ret <- try(str2lang(.cur[[i]]), silent=TRUE) + if (inherits(.ret, "try-error")) { + stop("rxode2 ui user function '", fun, "' failed to produce code that could be parsed '", .cur[[i]], + "' in $", + type, + call.=FALSE) + } + .ret + } else { + stop("rxode2 ui user function '", fun, "' failed to produce code that could be parsed in $", type, + call.=FALSE) + } + }) + assign(type, c(get(type, env), .ret), envir=env) + } else if (is.language(.cur)) { + assign(type, c(get(type, env), list(.cur)), envir=env) + } else if (inherits(.cur, "character")) { + .ret <- lapply(seq_along(.cur), + function(i) { + .ret <- try(str2lang(.cur[[i]]), silent=TRUE) + if (inherits(.ret, "try-error")) { + stop("rxode2 ui user function '", fun, "' failed to produce code that could be parsed '", .cur[[i]], + "' in $", + type, + call.=FALSE) + } + .ret + }) + assign(type, c(get(type, env), .ret), envir=env) + } else { + stop("rxode2 ui user function '", fun, "' failed to produce code that could be parsed in $", type, + call.=FALSE) + } +} diff --git a/R/rxPrune.R b/R/rxPrune.R index 1cb6874ab..b544ed496 100644 --- a/R/rxPrune.R +++ b/R/rxPrune.R @@ -1,13 +1,42 @@ -#' Internal Pruning function +#' Replace strings with numbers for the strAssign #' +#' @param lhs string for the left hand side of equation or variable +#' that is trying to be replaced with an integer +#' @param ret expression that will be returned if no replacement is +#' made +#' @param strAssign The `strAssign` list from the model variables +#' @return either `ret` or the integer that corresponds to the string +#' assignment +#' @noRd +#' @author Matthew L. Fidler +.rxPruneStrAssign <- function(lhs, ret, strAssign=list()) { + if (length(strAssign) == 0L) return(ret) + .w <- which(lhs %in% names(strAssign)) + if (length(.w) == 1L) { + # Replace with integer + .w <- which(vapply(seq_along(strAssign[[.w]]), + function(i) { + identical(ret, strAssign[[.w]][i]) + }, + logical(1))) + if (length(.w) == 1L) { + return(as.numeric(.w)) + } + } + ret +} + +#' Internal Pruning function #' #' @param x List of quoted lines #' @param envir Environment where information is stored +#' @param strAssign string assignment list from model variables #' @return Pruned model code #' @author Matthew L. Fidler #' @keywords internal #' @export -.rxPrune <- function(x, envir = parent.frame()) { +.rxPrune <- function(x, envir = parent.frame(), + strAssign=list()) { if (is.name(x) || is.atomic(x)) { if (is.character(x)) { return(deparse1(x)) @@ -16,60 +45,71 @@ } else if (is.call(x)) { if (identical(x[[1]], quote(`if`))) { .if <- envir$.if - .if[length(.if) + 1] <- .rxPrune(x[[2]], envir = envir) + .if[length(.if) + 1] <- .rxPrune(x[[2]], envir = envir, strAssign=strAssign) envir$.if <- .if .x2 <- x[-(1:2)] if (length(.x2) == 2) { - .ret1 <- .rxPrune(.x2[[1]], envir = envir) + .ret1 <- .rxPrune(.x2[[1]], envir = envir, strAssign=strAssign) .if[length(.if)] <- paste0("1-(", .if[length(.if)], ")") envir$.if <- .if .else <- envir$.else envir$.else <- unique(c(findLhs(eval(parse(text = paste0("quote({", .ret1, "})")))))) - .ret2 <- .rxPrune(.x2[[2]], envir = envir) + .ret2 <- .rxPrune(.x2[[2]], envir = envir, strAssign=strAssign) envir$.else <- .else .ret <- paste0(.ret1, "\n", .ret2) } else if (length(.x2) == 1) { - .ret <- .rxPrune(.x2[[1]], envir = envir) + .ret <- .rxPrune(.x2[[1]], envir = envir, strAssign=strAssign) } .if <- .if[-length(.if)] envir$.if <- .if return(.ret) } else if (identical(x[[1]], quote(`(`))) { - return(paste0("(", .rxPrune(x[[2]], envir = envir), ")")) + return(paste0("(", .rxPrune(x[[2]], envir = envir, strAssign=strAssign), ")")) } else if (identical(x[[1]], quote(`{`))) { .x2 <- x[-1] - return(paste0(lapply(.x2, .rxPrune, envir = envir), collapse = "\n")) + return(paste0(lapply(.x2, .rxPrune, envir = envir, strAssign=strAssign), collapse = "\n")) } else if (identical(x[[1]], quote(`==`)) || - identical(x[[1]], quote(`>=`)) || - identical(x[[1]], quote(`<=`)) || - identical(x[[1]], quote(`>`)) || - identical(x[[1]], quote(`<`)) || - identical(x[[1]], quote(`!=`)) || - identical(x[[1]], quote(`&&`)) || - identical(x[[1]], quote(`||`)) || - identical(x[[1]], quote(`&`)) || - identical(x[[1]], quote(`|`))) { + identical(x[[1]], quote(`!=`))) { + ## These cases can be strings that are assigned to integers. + ## Here we need to check left/right hand sides + .x2 <- deparse1(x[[2]]) + .x3 <- deparse1(x[[3]]) + x[[2]] <- .rxPruneStrAssign(.x3, x[[2]], strAssign=strAssign) + x[[3]] <- .rxPruneStrAssign(.x2, x[[3]], strAssign=strAssign) + .ret <- paste0( + .rxPrune(x[[2]], envir = envir, strAssign=strAssign), as.character(x[[1]]), + .rxPrune(x[[3]], envir = envir, strAssign=strAssign)) + return(.ret) + } else if (identical(x[[1]], quote(`>=`)) || + identical(x[[1]], quote(`<=`)) || + identical(x[[1]], quote(`>`)) || + identical(x[[1]], quote(`<`)) || + identical(x[[1]], quote(`&&`)) || + identical(x[[1]], quote(`||`)) || + identical(x[[1]], quote(`&`)) || + identical(x[[1]], quote(`|`))) { .ret <- paste0( - .rxPrune(x[[2]], envir = envir), as.character(x[[1]]), - .rxPrune(x[[3]], envir = envir) - ) + .rxPrune(x[[2]], envir = envir, strAssign=strAssign), as.character(x[[1]]), + .rxPrune(x[[3]], envir = envir, strAssign=strAssign)) return(.ret) } else if (identical(x[[1]], quote(`=`)) || - identical(x[[1]], quote(`<-`)) || - identical(x[[1]], quote(`~`))) { + identical(x[[1]], quote(`<-`)) || + identical(x[[1]], quote(`~`))) { + .lhs <- deparse1(x[[2]]) + x[[3]] <- .rxPruneStrAssign(.lhs, x[[3]], strAssign=strAssign) if (length(envir$.if > 0)) { - .f2 <- .rxPrune(x[[2]], envir = envir) + .f2 <- .rxPrune(x[[2]], envir = envir, strAssign=strAssign) .if <- paste0(paste0("(", envir$.if, ")"), collapse = "*") if (any(envir$.def1 == .f2)) { .ret <- paste0( .f2, as.character(x[[1]]), .if, "*(", - .rxPrune(x[[3]], envir = envir), ")+(1-(", .if, "))*(", + .rxPrune(x[[3]], envir = envir, strAssign), ")+(1-(", .if, "))*(", .f2, ")" ) } else { .ret <- paste0( .f2, as.character(x[[1]]), .if, "*(", - .rxPrune(x[[3]], envir = envir), ")", + .rxPrune(x[[3]], envir = envir, strAssign=strAssign), ")", ifelse(any(envir$.else == .f2), paste0("+", .f2), "" ) @@ -78,11 +118,11 @@ assign(".def1", unique(c(envir$.def1, .f2)), envir) return(.ret) } else { - .f2 <- .rxPrune(x[[2]], envir = envir) + .f2 <- .rxPrune(x[[2]], envir = envir, strAssign=strAssign) assign(".def1", unique(c(envir$.def1, .f2)), envir) return(paste0( .f2, as.character(x[[1]]), - .rxPrune(x[[3]], envir = envir) + .rxPrune(x[[3]], envir = envir, strAssign=strAssign) )) } } else if (identical(x[[1]], quote(`*`)) || @@ -92,20 +132,20 @@ identical(x[[1]], quote(`/`))) { if (length(x) == 3) { return(paste0( - .rxPrune(x[[2]], envir = envir), as.character(x[[1]]), - .rxPrune(x[[3]], envir = envir) + .rxPrune(x[[2]], envir = envir, strAssign=strAssign), as.character(x[[1]]), + .rxPrune(x[[3]], envir = envir, strAssign=strAssign) )) } else { ## Unary Operators return(paste0( as.character(x[[1]]), - .rxPrune(x[[2]], envir = envir) + .rxPrune(x[[2]], envir = envir, strAssign=strAssign) )) } } else if (identical(x[[1]], quote(`ifelse`))) { - .f2 <- .rxPrune(x[[2]], envir = envir) - .f3 <- .rxPrune(x[[3]], envir = envir) - .f4 <- .rxPrune(x[[4]], envir = envir) + .f2 <- .rxPrune(x[[2]], envir = envir, strAssign=strAssign) + .f3 <- .rxPrune(x[[3]], envir = envir, strAssign=strAssign) + .f4 <- .rxPrune(x[[4]], envir = envir, strAssign=strAssign) return(paste0("((", .f2, ")*(", .f3, ")+(1-(", .f2, "))*(", .f4, "))")) } else if (identical(x[[1]], quote(`[`))) { .type <- toupper(as.character(x[[2]])) @@ -113,7 +153,7 @@ ## only will take legal rxode2; Therefore just paste these. return(paste0(.type, "[", x[[3]], "]")) } else { - .ret0 <- lapply(x, .rxPrune, envir = envir) + .ret0 <- lapply(x, .rxPrune, envir = envir, strAssign=strAssign) .ret <- paste0(.ret0[[1]], "(") .ret0 <- .ret0[-1] .ret <- paste0(.ret, paste0(unlist(.ret0), collapse = ", "), ")") @@ -137,8 +177,9 @@ #' @export rxPrune <- function(x) { .env <- new.env(parent = emptyenv()) + .mv <- rxModelVars(x) .env$.if <- NULL .env$.def1 <- NULL - .ret <- .rxPrune(eval(parse(text = paste0("quote({", rxNorm(x), "})"))), envir = .env) + .ret <- .rxPrune(eval(parse(text = paste0("quote({", rxNorm(x), "})"))), envir = .env, strAssign=.mv$strAssign) return(.ret) } diff --git a/R/rxUiBlessed.R b/R/rxUiBlessed.R index efce3d7f8..f37342b9d 100644 --- a/R/rxUiBlessed.R +++ b/R/rxUiBlessed.R @@ -5,5 +5,5 @@ "modelName", "mu2RefCovariateReplaceDataFrame", "muRefCovariateDataFrame", "muRefCovariateEmpty", "muRefCurEval", "muRefDataFrame", "muRefDropParameters", "muRefExtra", "muRefExtraEmpty", "mv0", - "mvL", "nonMuEtas", "oneTheta", "predDf", "singleTheta", - "sticky", "thetaLhsDf") + "mvL", "nonMuEtas", "oneTheta", "predDf", "redo", "singleTheta", + "sticky", "thetaLhsDf", "uiUseData", "uiUseMv") diff --git a/R/rxUiGet.R b/R/rxUiGet.R index 3c4f2cabd..bb84d6640 100644 --- a/R/rxUiGet.R +++ b/R/rxUiGet.R @@ -49,6 +49,21 @@ rxUiGet <- function(x, ...) { UseMethod("rxUiGet") } +#' @rdname rxUiGet +#' @export +rxUiGet.levels <- function(x, ...) { + .x <- x[[1]] + .mv <- rxModelVars(.x) + .str <- .mv$strAssign + .names <- names(.str) + lapply(vapply(seq_along(.str), function(i) { + paste0("levels(", .names[i], ") <- ", + deparse1(.str[[i]])) + }, character(1), USE.NAMES=FALSE), + str2lang) +} + +#' @rdname rxUiGet #' @export rxUiGet.state <- function(x, ...) { .ui <- x[[1]] @@ -56,6 +71,7 @@ rxUiGet.state <- function(x, ...) { } attr(rxUiGet.state, "desc") <- "states associated with the model (in order)" +#' @rdname rxUiGet #' @export rxUiGet.stateDf <- function(x, ...) { .ui <- x[[1]] @@ -67,7 +83,38 @@ attr(rxUiGet.stateDf, "desc") <- "states and cmt number data.frame" #' @export #' @rdname rxUiGet -rxUiGet.params <- function(x, ...) { +rxUiGet.statePropDf <- function(x,...) { + .ui <- x[[1]] + .mv <- rxModelVars(.ui) + do.call(rbind, lapply(seq_along(.mv$stateProp), + function(i) { + .prop <- .mv$stateProp[i] + if (.prop == 0) return(NULL) + .name <- names(.mv$stateProp)[i] + .props <- character(0) + if (bitwAnd(.prop, 1)) { + .props <- c(.props, "ini") + } + if (bitwAnd(.prop, 2)) { + .props <- c(.props, "f") + } + if (bitwAnd(.prop, 4)) { + .props <- c(.props, "alag") + } + if (bitwAnd(.prop, 8)) { + .props <- c(.props, "rate") + } + if (bitwAnd(.prop, 16)) { + .props <- c(.props, "dur") + } + data.frame("Compartment"=.name, + "Property"=.props) + })) +} + +#' @export +#' @rdname rxUiGet +rxUiGet.props <- function(x, ...) { .x <- x[[1]] .ini <- .x$iniDf .w <- !is.na(.ini$ntheta) & is.na(.ini$err) @@ -106,8 +153,9 @@ rxUiGet.params <- function(x, ...) { .dose <- c(.doseExtra, .x$state) names(.var) <- .cnds .lhs <- .mv$lhs + .state <- .mv$state .end <- .x$predDf$var - .end <- .end[.end %in% .lhs] + .end <- .end[.end %in% c(.lhs, .state)] .lhs <- .lhs[!(.lhs %in% .end)] .varLhs <- .x$varLhs .primary <- .lhs[.lhs %in% .varLhs] @@ -120,9 +168,10 @@ rxUiGet.params <- function(x, ...) { output=list(primary=.primary, secondary=.secondary, endpoint=.end, - state=.x$state)) + state=.x$state), + cmtProp=rxUiGet.statePropDf(x,...)) } -attr(rxUiGet.params, "desc") <- "Parameter names" +attr(rxUiGet.props, "desc") <- "rxode2 model properties" #' @export #' @rdname rxUiGet @@ -235,6 +284,49 @@ rxUiGet.multipleEndpoint <- function(x, ...) { } attr(rxUiGet.multipleEndpoint, "desc") <- "table of multiple endpoint translations" +#' This is a generic function for deparsing certain objects when +#' printing out a rxode2 object. Currently it is used for any meta-information +#' +#' @param object object to be deparsed +#' @param var variable name to be assigned +#' @return parsed R expression that can be used for printing and +#' `as.function()` calls. +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' mat <- matrix(c(1, 0.1, 0.1, 1), 2, 2, dimnames=list(c("a", "b"), c("a", "b"))) +#' +#' rxUiDeparse(matrix(c(1, 0.1, 0.1, 1), 2, 2, dimnames=list(c("a", "b"), c("a", "b"))), "x") +rxUiDeparse <- function(object, var) { + UseMethod("rxUiDeparse") +} + +#' @rdname rxUiDeparse +#' @export +rxUiDeparse.lotriFix <- function(object, var) { + .val <- lotri::lotriAsExpression(object) + bquote(.(str2lang(var)) <- .(.val)) +} + +#' @rdname rxUiDeparse +#' @export +rxUiDeparse.default <- function(object, var) { + # This is a default method for deparsing objects + if (checkmate::testMatrix(object, any.missing=FALSE, + row.names="strict", col.names="strict")) { + .dn <- dimnames(object) + if (identical(.dn[[1]], .dn[[2]]) && isSymmetric(object)) { + return(rxUiDeparse.lotriFix(object, var)) + } + } + .ret <- try(str2lang(paste0(var, "<-", deparse1(object)))) + if (inherits(.ret, "try-error")) { + .ret <- str2lang("NULL") + } + .ret +} + #' @rdname rxUiGet #' @export rxUiGet.funPrint <- function(x, ...) { @@ -246,20 +338,7 @@ rxUiGet.funPrint <- function(x, ...) { for (.i in seq_along(.ls)) { .var <- .ls[.i] .val <- .x$meta[[.ls[.i]]] - .isLotri <- FALSE - if (checkmate::testMatrix(.val, any.missing=FALSE, row.names="strict", col.names="strict")) { - .dn <- dimnames(.val) - if (identical(.dn[[1]], .dn[[2]]) && isSymmetric(.val)) { - class(.val) <- c("lotriFix", class(.val)) - .val <- as.expression(.val) - .val <- bquote(.(str2lang(.var)) <- .(.val)) - .ret[[.i + 1]] <- .val - .isLotri <- TRUE - } - } - if (!.isLotri) { - .ret[[.i + 1]] <- eval(parse(text=paste("quote(", .var, "<-", deparse1(.val), ")"))) - } + .ret[[.i + 1]] <- rxUiDeparse(.val, .var) } .theta <- x$theta .omega <- x$omega diff --git a/R/rxode-options.R b/R/rxode-options.R index 866c93420..8bbc0faaa 100644 --- a/R/rxode-options.R +++ b/R/rxode-options.R @@ -16,7 +16,20 @@ } } .hasUnits <- FALSE -.PreciseSumsVersion <- utils::packageVersion("PreciseSums") +#' Get the rxode2 function pointers +#' +#' This function is used to get the function pointers for rxode2. This is +#' used to allow rxode2 to have binary linkage to nlmixr2est. +#' +#' @return a list of function pointers +#' @export +#' @author Matthew L. Fidler +#' @examples +#' +#' .rxode2ptrs() +.rxode2ptrs <- function() { + .Call(`_rxode2_rxode2Ptr`, PACKAGE = "rxode2") +} ## nocov start .onLoad <- function(libname, pkgname) { @@ -33,15 +46,6 @@ if (requireNamespace("data.table", quietly = TRUE)) { .s3register("data.table::as.data.table", "rxEt") } - if (!identical(.PreciseSumsVersion, utils::packageVersion("PreciseSums"))) { - stop("rxode2 compiled with PreciseSums '", as.character(.PreciseSumsVersion), - "' but PreciseSums '", as.character(utils::packageVersion("PreciseSums")), - "' is loaded\nRecompile rxode2 with the this version of PreciseSums", - call. = FALSE - ) - } else { - requireNamespace("PreciseSums", quietly=TRUE) - } if (requireNamespace("dplyr", quietly=TRUE)) { .s3register("dplyr::rename", "rxUi") .s3register("dplyr::rename", "function") @@ -70,8 +74,29 @@ setProgSupported(0) } .ggplot2Fix() + .linkAll() + forderForceBase(FALSE) } ## nocov end +.iniLotriPtrs <- function() { + .Call(`_iniLotriPtr`, lotri::.lotriPointers()) +} + +.iniPreciseSumsPtr <- function() { + .Call(`_iniPreciseSumsPtr`, PreciseSums::.preciseSumsPtr()) +} + +.iniDparserPtr <- function() { + .Call(`_rxode2_iniDparserPtr`, dparser::.dparsePtr()) +} + +.linkAll <- function() { + .iniLotriPtrs() + .iniPreciseSumsPtr() + .iniDparserPtr() +} + + .onAttach <- function(libname, pkgname) { ## For some strange reason, mvnfast needs to be loaded before rxode2 to work correctly .Call(`_rxode2_setRstudio`, Sys.getenv("RSTUDIO") == "1") @@ -79,6 +104,8 @@ if (!interactive()) { setProgSupported(0) } + .linkAll() + rxTempDir() .ggplot2Fix() v <- utils::packageVersion("rxode2") @@ -99,6 +126,7 @@ "\n========================================\n" ) } + forderForceBase(FALSE) } .onUnload <- function(libpath) { @@ -202,13 +230,12 @@ rxOpt <- list( rxode2.calculate.jacobian = c(FALSE, FALSE), rxode2.calculate.sensitivity = c(FALSE, FALSE), rxode2.verbose = c(TRUE, TRUE), - rxode2.verbose.pipe = c(TRUE, TRUE), rxode2.suppress.syntax.info = c(FALSE, FALSE), rxode2.sympy.engine = c("", ""), rxode2.cache.directory = c(.cacheDefault, .cacheDefault), rxode2.tempfiles = c(TRUE, TRUE), rxode2.sympy.run.internal = c(FALSE, FALSE), - rxode2.syntax.require.ode.first = c(TRUE, TRUE), + rxode2.syntax.require.ode.first = c(FALSE, FALSE), rxode2.compile.O = c("3", "3"), rxode2.unload.unused = c(FALSE, FALSE), rxode2.debug=c(FALSE, FALSE) @@ -230,7 +257,6 @@ rxode2.syntax.require.ode.first <- NULL rxode2.compile.O <- NULL rxode2.unload.unused <- NULL rxode2.debug <- NULL -rxode2.verbose.pipe <- NULL .isTestthat <- function() { return(regexpr("/tests/testthat/", getwd(), fixed = TRUE) != -1) # nolint diff --git a/R/rxrandom.R b/R/rxrandom.R index 27cb2ffae..a27050fc6 100644 --- a/R/rxrandom.R +++ b/R/rxrandom.R @@ -51,6 +51,8 @@ rxnormV <- function(mean = 0, sd = 1, n = 1L, ncores = 1L) { #' @export rxnorm <- rxnormV + + #' Simulate random Poisson variable from threefry generator #' #' @inheritParams stats::rpois @@ -89,7 +91,6 @@ rxpois <- function(lambda, n = 1L, ncores = 1L) { .Call(`_rxode2_rxpois_`, lambda, n, ncores) } - #' Simulate student t variable from threefry generator #' #' @inheritParams stats::rt @@ -1283,3 +1284,10 @@ rxRmvn <- function(n, mu = NULL, sigma, lower = -Inf, upper = Inf, ncores = 1, i } return(.ret) } + +#' @export +rxUdfUi.rxpois <- function(fun) { + .fun <- fun + .fun[[1]] <- str2lang(paste0(".", deparse1(fun[[1]]))) + eval(.fun) +} diff --git a/R/rxrandomui.R b/R/rxrandomui.R new file mode 100644 index 000000000..5c1b5da80 --- /dev/null +++ b/R/rxrandomui.R @@ -0,0 +1,560 @@ +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxnorm <- function(mean = 0, sd = 1) { + .mean <- as.character(substitute(mean)) + .tmp <- suppressWarnings(try(force(mean), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .mean <- mean + } + } + .sd <- as.character(substitute(sd)) + .tmp <- suppressWarnings(try(force(sd), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .sd <- sd + } + } + list(replace = paste0("rxnorm(", .mean, ", ", .sd, ")")) +} + +#'@export +rxUdfUi.rxnorm <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxpois <- function(lambda) { + .lambda <- as.character(substitute(lambda)) + .tmp <- suppressWarnings(try(force(lambda), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .lambda <- lambda + } + } + list(replace = paste0("rxpois(", .lambda, ")")) +} + +#'@export +rxUdfUi.rxpois <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxt <- function(df) { + .df <- as.character(substitute(df)) + .tmp <- suppressWarnings(try(force(df), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df <- df + } + } + list(replace = paste0("rxt(", .df, ")")) +} + +#'@export +rxUdfUi.rxt <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxunif <- function(min = 0, max = 1) { + .min <- as.character(substitute(min)) + .tmp <- suppressWarnings(try(force(min), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .min <- min + } + } + .max <- as.character(substitute(max)) + .tmp <- suppressWarnings(try(force(max), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .max <- max + } + } + list(replace = paste0("rxunif(", .min, ", ", .max, ")")) +} + +#'@export +rxUdfUi.rxunif <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxweibull <- function(shape, scale = 1) { + .shape <- as.character(substitute(shape)) + .tmp <- suppressWarnings(try(force(shape), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape <- shape + } + } + .scale <- as.character(substitute(scale)) + .tmp <- suppressWarnings(try(force(scale), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .scale <- scale + } + } + list(replace = paste0("rxweibull(", .shape, ", ", .scale, + ")")) +} + +#'@export +rxUdfUi.rxweibull <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxgeom <- function(prob) { + .prob <- as.character(substitute(prob)) + .tmp <- suppressWarnings(try(force(prob), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .prob <- prob + } + } + list(replace = paste0("rxgeom(", .prob, ")")) +} + +#'@export +rxUdfUi.rxgeom <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxbeta <- function(shape1, shape2) { + .shape1 <- as.character(substitute(shape1)) + .tmp <- suppressWarnings(try(force(shape1), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape1 <- shape1 + } + } + .shape2 <- as.character(substitute(shape2)) + .tmp <- suppressWarnings(try(force(shape2), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape2 <- shape2 + } + } + list(replace = paste0("rxbeta(", .shape1, ", ", .shape2, + ")")) +} + +#'@export +rxUdfUi.rxbeta <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxgamma <- function(shape, rate = 1) { + .shape <- as.character(substitute(shape)) + .tmp <- suppressWarnings(try(force(shape), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape <- shape + } + } + .rate <- as.character(substitute(rate)) + .tmp <- suppressWarnings(try(force(rate), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .rate <- rate + } + } + list(replace = paste0("rxgamma(", .shape, ", ", .rate, ")")) +} + +#'@export +rxUdfUi.rxgamma <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxf <- function(df1, df2) { + .df1 <- as.character(substitute(df1)) + .tmp <- suppressWarnings(try(force(df1), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df1 <- df1 + } + } + .df2 <- as.character(substitute(df2)) + .tmp <- suppressWarnings(try(force(df2), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df2 <- df2 + } + } + list(replace = paste0("rxf(", .df1, ", ", .df2, ")")) +} + +#'@export +rxUdfUi.rxf <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxexp <- function(rate) { + .rate <- as.character(substitute(rate)) + .tmp <- suppressWarnings(try(force(rate), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .rate <- rate + } + } + list(replace = paste0("rxexp(", .rate, ")")) +} + +#'@export +rxUdfUi.rxexp <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxchisq <- function(df) { + .df <- as.character(substitute(df)) + .tmp <- suppressWarnings(try(force(df), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df <- df + } + } + list(replace = paste0("rxchisq(", .df, ")")) +} + +#'@export +rxUdfUi.rxchisq <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxcauchy <- function(location = 0, scale = 1) { + .location <- as.character(substitute(location)) + .tmp <- suppressWarnings(try(force(location), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .location <- location + } + } + .scale <- as.character(substitute(scale)) + .tmp <- suppressWarnings(try(force(scale), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .scale <- scale + } + } + list(replace = paste0("rxcauchy(", .location, ", ", .scale, + ")")) +} + +#'@export +rxUdfUi.rxcauchy <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rxbinom <- function(size, prob) { + .size <- as.character(substitute(size)) + .tmp <- suppressWarnings(try(force(size), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .size <- size + } + } + .prob <- as.character(substitute(prob)) + .tmp <- suppressWarnings(try(force(prob), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .prob <- prob + } + } + list(replace = paste0("rxbinom(", .size, ", ", .prob, ")")) +} + +#'@export +rxUdfUi.rxbinom <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rinorm <- function(mean = 0, sd = 1) { + .mean <- as.character(substitute(mean)) + .tmp <- suppressWarnings(try(force(mean), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .mean <- mean + } + } + .sd <- as.character(substitute(sd)) + .tmp <- suppressWarnings(try(force(sd), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .sd <- sd + } + } + list(replace = paste0("rinorm(", .mean, ", ", .sd, ")")) +} + +#'@export +rxUdfUi.rinorm <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.ripois <- function(lambda) { + .lambda <- as.character(substitute(lambda)) + .tmp <- suppressWarnings(try(force(lambda), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .lambda <- lambda + } + } + list(replace = paste0("ripois(", .lambda, ")")) +} + +#'@export +rxUdfUi.ripois <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rit <- function(df) { + .df <- as.character(substitute(df)) + .tmp <- suppressWarnings(try(force(df), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df <- df + } + } + list(replace = paste0("rit(", .df, ")")) +} + +#'@export +rxUdfUi.rit <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.riunif <- function(min = 0, max = 1) { + .min <- as.character(substitute(min)) + .tmp <- suppressWarnings(try(force(min), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .min <- min + } + } + .max <- as.character(substitute(max)) + .tmp <- suppressWarnings(try(force(max), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .max <- max + } + } + list(replace = paste0("riunif(", .min, ", ", .max, ")")) +} + +#'@export +rxUdfUi.riunif <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.riweibull <- function(shape, scale = 1) { + .shape <- as.character(substitute(shape)) + .tmp <- suppressWarnings(try(force(shape), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape <- shape + } + } + .scale <- as.character(substitute(scale)) + .tmp <- suppressWarnings(try(force(scale), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .scale <- scale + } + } + list(replace = paste0("riweibull(", .shape, ", ", .scale, + ")")) +} + +#'@export +rxUdfUi.riweibull <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rigeom <- function(prob) { + .prob <- as.character(substitute(prob)) + .tmp <- suppressWarnings(try(force(prob), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .prob <- prob + } + } + list(replace = paste0("rigeom(", .prob, ")")) +} + +#'@export +rxUdfUi.rigeom <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.ribeta <- function(shape1, shape2) { + .shape1 <- as.character(substitute(shape1)) + .tmp <- suppressWarnings(try(force(shape1), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape1 <- shape1 + } + } + .shape2 <- as.character(substitute(shape2)) + .tmp <- suppressWarnings(try(force(shape2), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape2 <- shape2 + } + } + list(replace = paste0("ribeta(", .shape1, ", ", .shape2, + ")")) +} + +#'@export +rxUdfUi.ribeta <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rigamma <- function(shape, rate = 1) { + .shape <- as.character(substitute(shape)) + .tmp <- suppressWarnings(try(force(shape), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .shape <- shape + } + } + .rate <- as.character(substitute(rate)) + .tmp <- suppressWarnings(try(force(rate), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .rate <- rate + } + } + list(replace = paste0("rigamma(", .shape, ", ", .rate, ")")) +} + +#'@export +rxUdfUi.rigamma <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.rif <- function(df1, df2) { + .df1 <- as.character(substitute(df1)) + .tmp <- suppressWarnings(try(force(df1), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df1 <- df1 + } + } + .df2 <- as.character(substitute(df2)) + .tmp <- suppressWarnings(try(force(df2), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df2 <- df2 + } + } + list(replace = paste0("rif(", .df1, ", ", .df2, ")")) +} + +#'@export +rxUdfUi.rif <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.riexp <- function(rate) { + .rate <- as.character(substitute(rate)) + .tmp <- suppressWarnings(try(force(rate), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .rate <- rate + } + } + list(replace = paste0("riexp(", .rate, ")")) +} + +#'@export +rxUdfUi.riexp <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.richisq <- function(df) { + .df <- as.character(substitute(df)) + .tmp <- suppressWarnings(try(force(df), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .df <- df + } + } + list(replace = paste0("richisq(", .df, ")")) +} + +#'@export +rxUdfUi.richisq <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.ricauchy <- function(location = 0, scale = 1) { + .location <- as.character(substitute(location)) + .tmp <- suppressWarnings(try(force(location), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .location <- location + } + } + .scale <- as.character(substitute(scale)) + .tmp <- suppressWarnings(try(force(scale), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .scale <- scale + } + } + list(replace = paste0("ricauchy(", .location, ", ", .scale, + ")")) +} + +#'@export +rxUdfUi.ricauchy <- rxUdfUi.rxpois + +## nocov end +# This file is generated by .generateRandomUiFuns() in build.R +## nocov start +.ribinom <- function(size, prob) { + .size <- as.character(substitute(size)) + .tmp <- suppressWarnings(try(force(size), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .size <- size + } + } + .prob <- as.character(substitute(prob)) + .tmp <- suppressWarnings(try(force(prob), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .prob <- prob + } + } + list(replace = paste0("ribinom(", .size, ", ", .prob, ")")) +} + +#'@export +rxUdfUi.ribinom <- rxUdfUi.rxpois + +## nocov end diff --git a/R/rxsolve.R b/R/rxsolve.R index 990c1d0ef..812c4422e 100644 --- a/R/rxsolve.R +++ b/R/rxsolve.R @@ -162,9 +162,15 @@ #' upper range to make sure all state values are in the #' reasonable range. #' -#' @param safeZero Use safe zero divide and log routines. By default +#' @param safeZero Use safe zero divide. By default #' this is turned on but you may turn it off if you wish. #' +#' @param safePow Use safe powers. When enabled if your power is +#' negative and your base is zero, this will return the `machine +#' epsilon^(negative power)`. By default this is turned on. +#' +#' @param safeLog Use safe log. When enabled if your value that you are taking log() of is negative or zero, this will return `log(machine epsilon)`. By default this is turned on. +#' #' @param sumType Sum type to use for `sum()` in #' rxode2 code blocks. #' @@ -261,6 +267,19 @@ #' end/beginning of the individual record, switch direction. If all #' are really missing, then return missing. #' +#' @param keepInterpolation specifies the interpolation method for +#' variables in the `keep` column. When `nlmixr2` creates `mtime`, +#' `addl` doses etc, these items were not originally in the dataset. +#' The interpolation methods you can choose are: +#' +#' * `"locf"` -- last observation carried forward (default) +#' +#' * `"nocb"` -- next observation carried backward. +#' +#' * `"na"` -- no interpolation, simply put `NA` for the +#' interpolated `keep` covariates. +#' +#' #' @param addCov A boolean indicating if covariates should be added #' to the output matrix or data frame. By default this is #' disabled. @@ -686,6 +705,7 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, cores, covsInterpolation = c("locf", "linear", "nocb", "midpoint"), naInterpolation = c("locf", "nocb"), + keepInterpolation=c("na", "locf", "nocb"), addCov = TRUE, sigma = NULL, sigmaDf = NULL, sigmaLower = -Inf, sigmaUpper = Inf, nCoresRV = 1L, sigmaIsChol = FALSE, @@ -702,7 +722,8 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, omegaXform = c("variance", "identity", "log", "nlmixrSqrt", "nlmixrLog", "nlmixrIdentity"), omegaLower = -Inf, omegaUpper = Inf, nSub = 1L, thetaMat = NULL, thetaDf = NULL, thetaIsChol = FALSE, - nStud = 1L, dfSub = 0.0, dfObs = 0.0, returnType = c("rxSolve", "matrix", "data.frame", "data.frame.TBS", "data.table", "tbl", "tibble"), + nStud = 1L, dfSub = 0.0, dfObs = 0.0, + returnType = c("rxSolve", "matrix", "data.frame", "data.frame.TBS", "data.table", "tbl", "tibble"), seed = NULL, nsim = NULL, minSS = 10L, maxSS = 1000L, infSSstep = 12, @@ -729,6 +750,8 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, ssAtol = 1.0e-8, ssRtol = 1.0e-6, safeZero = TRUE, + safeLog = TRUE, + safePow = TRUE, sumType = c("pairwise", "fsum", "kahan", "neumaier", "c"), prodType = c("long double", "double", "logify"), sensType = c("advan", "autodiff", "forward", "central"), @@ -819,11 +842,16 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, } else { covsInterpolation <- c("linear"=0L, "locf"=1L, "nocb"=2L, "midpoint"=3L)[match.arg(covsInterpolation)] } - if (checkmate::testIntegerish(naInterpolation, len=1, lower=0, upper=2, any.missing=FALSE)) { + if (checkmate::testIntegerish(naInterpolation, len=1, lower=0, upper=1, any.missing=FALSE)) { naInterpolation <- as.integer(naInterpolation) } else { naInterpolation <- c("locf"=1L, "nocb"=0L)[match.arg(naInterpolation)] } + if (checkmate::testIntegerish(keepInterpolation, len=1, lower=0, upper=2, any.missing=FALSE)) { + keepInterpolation <- as.integer(keepInterpolation) + } else { + keepInterpolation <- c("locf"=1L, "nocb"=0L, "na"=2L)[match.arg(keepInterpolation)] + } if (missing(naTimeHandle) && !is.null(getOption("rxode2.naTimeHandle", NULL))) { naTimeHandle <- getOption("rxode2.naTimeHandle") } @@ -895,6 +923,14 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, checkmate::assertLogical(safeZero, len=1, any.missing=FALSE) } safeZero <- as.integer(safeZero) + if (!checkmate::testIntegerish(safeLog, lower=0, upper=1, len=1, any.missing=FALSE)) { + checkmate::assertLogical(safeLog, len=1, any.missing=FALSE) + } + safeLog <- as.integer(safeLog) + if (!checkmate::testIntegerish(safePow, lower=0, upper=1, len=1, any.missing=FALSE)) { + checkmate::assertLogical(safePow, len=1, any.missing=FALSE) + } + safePow <- as.integer(safePow) if (is.null(scale)) { } else if (is.list(scale)) { checkmate::assertList(scale, types="double", any.missing=FALSE,names="strict") @@ -989,7 +1025,23 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, checkmate::assertNumeric(dfObs, len=1, any.missing=FALSE, finite=TRUE, lower=0.0) # iCov = data.frame checkmate::assertDataFrame(iCov, null.ok=TRUE) - checkmate::assertCharacter(keep, any.missing=FALSE, null.ok=TRUE) + .invalidKeep <- c("id", "sim.id", "resetno", "time") + .invalidKeep <- intersect(tolower(keep), tolower(.invalidKeep)) + if (length(.invalidKeep) > 0) { + .w <- which(tolower(keep) %in% .invalidKeep) + keep <- keep[-.w] + warning("'keep' contains ", paste(.invalidKeep, collapse=", "), "\nwhich are output when needed, ignoring these items", call.=FALSE) + } + .invalidKeep <- c("evid", "ss", "amt", "rate", "dur", "ii") + .invalidKeep <- intersect(tolower(keep), tolower(.invalidKeep)) + if (length(.invalidKeep) > 0) { + stop("'keep' cannot contain ", paste(.invalidKeep, collapse=", "), "\nconsider using addDosing=TRUE or merging to original dataset", call.=FALSE) + } + .invalidKeep <- c ("rxLambda", "rxYj", "rxLow", "rxHi") + .invalidKeep <- intersect(tolower(keep), tolower(.invalidKeep)) + if (length(.invalidKeep) > 0) { + stop("'keep' cannot contain ", paste(.invalidKeep, collapse=", "), "\nconsider using returnType=\"data.frame.TBS\"", call.=FALSE) + } checkmate::assertCharacter(drop, any.missing=FALSE, null.ok=TRUE) checkmate::assertLogical(warnDrop, len=1, any.missing=FALSE) checkmate::assertNumeric(omegaLower, any.missing=FALSE, null.ok=TRUE) @@ -1158,6 +1210,9 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, ssAtDoseTime=ssAtDoseTime, ss2cancelAllPending=ss2cancelAllPending, naInterpolation=naInterpolation, + keepInterpolation=keepInterpolation, + safeLog=safeLog, + safePow=safePow, .zeros=unique(.zeros) ) class(.ret) <- "rxControl" @@ -1170,6 +1225,19 @@ rxSolve <- function(object, params = NULL, events = NULL, inits = NULL, #' @export rxSolve.function <- function(object, params = NULL, events = NULL, inits = NULL, ..., theta = NULL, eta = NULL, envir=parent.frame()) { + rxUdfUiReset() + if (rxIs(events, "event.data.frame")) { + rxUdfUiData(events) + } else if (rxIs(params, "event.data.frame")) { + rxUdfUiData(params) + } else { + stop("Cannot detect an event data frame to use while re-parsing the model", + call.=FALSE) + } + rxUdfUiEst("rxSolve") + on.exit({ + rxUdfUiReset() + }) .udfEnvSet(list(envir, parent.frame(1))) .object <- rxode2(object) do.call("rxSolve", c(list(object=.object, params = params, events = events, inits = inits), @@ -1320,6 +1388,27 @@ rxSolve.function <- function(object, params = NULL, events = NULL, inits = NULL, #' @export rxSolve.rxUi <- function(object, params = NULL, events = NULL, inits = NULL, ..., theta = NULL, eta = NULL, envir=parent.frame()) { + rxUdfUiReset() + if (isTRUE(object$uiUseData)) { + # this needs to be re-parsed + if (rxIs(events, "event.data.frame")) { + rxUdfUiData(events) + rxUdfUiMv(rxModelVars(object)) + } else if (rxIs(params, "event.data.frame")) { + rxUdfUiData(params) + rxUdfUiMv(rxModelVars(object)) + } else { + stop("Cannot detect an event data frame to use while re-parsing the model", + call.=FALSE) + } + rxUdfUiEst("rxSolve") + on.exit({ + rxUdfUiReset() + }) + # Now re-parse + object <- as.function(object) + object <- suppressMessages(rxode2(object)) + } .udfEnvSet(list(object$meta, envir, parent.frame(1))) if (inherits(object, "rxUi")) { object <- rxUiDecompress(object) @@ -1368,6 +1457,7 @@ rxSolve.rxode2tos <- rxSolve.rxUi #' @export rxSolve.nlmixr2FitData <- function(object, params = NULL, events = NULL, inits = NULL, ..., theta = NULL, eta = NULL, envir=parent.frame()) { + rxUdfUiReset() .udfEnvSet(list(envir, parent.frame(1))) .lst <- .rxSolveFromUi(object, params = params, events = events, inits = inits, ..., theta = theta, eta = eta) .rxControl <- .lst[[2]] @@ -1377,11 +1467,13 @@ rxSolve.nlmixr2FitData <- function(object, params = NULL, events = NULL, inits = .oldControl <- get("control", envir=.env) assign("control", .rxControl, envir=.env) on.exit({ + rxUdfUiReset() assign("control", .oldControl, envir=.env) }) } else { assign("control", .rxControl, envir=.env) on.exit({ + rxUdfUiReset() rm(list="control", envir=.env) }) } @@ -1403,8 +1495,10 @@ rxSolve.nlmixr2FitCore <- rxSolve.nlmixr2FitData #' @export rxSolve.default <- function(object, params = NULL, events = NULL, inits = NULL, ..., theta = NULL, eta = NULL, envir=parent.frame()) { + rxUdfUiReset() .udfEnvSet(list(envir, parent.frame(1))) on.exit({ + rxUdfUiReset() .clearPipe() .asFunctionEnv$rx <- NULL }) @@ -1709,16 +1803,9 @@ rxSolve.default <- function(object, params = NULL, events = NULL, inits = NULL, .envReset$unload <- FALSE # take care of too many DLLs or not provided simulation errors .names <- NULL - if (inherits(.ctl$thetaMat, "matrix")) { - .mv <- rxModelVars(object) - .col <- colnames(.ctl$thetaMat) - .w <- .col %in% .mv$params - .ignore <- .col[!.w] - if (length(.ignore)>0) { - .minfo(paste0("thetaMat has too many items, ignored: '", paste(.ignore, collapse="', '"), "'")) - } - .names <- c(.names, .col[.w]) - } + + .extraNames <- character(0) + if (inherits(.ctl$omega, "matrix")) { .mv <- rxModelVars(object) .col <- colnames(.ctl$omega) @@ -1727,8 +1814,14 @@ rxSolve.default <- function(object, params = NULL, events = NULL, inits = NULL, if (length(.ignore)>0) { .minfo(paste0("omega has too many items, ignored: '", paste(.ignore, collapse="', '"), "'")) } + .ctl$omega <-.ctl$omega[.w, .w, drop=FALSE] + if (dim(.ctl$omega)[1] == 0) { + .ctl$omega <- NULL + .ctl <- do.call(rxControl, .ctl) + } .names <- c(.names, .col[.w]) } else if ( inherits(.ctl$omega, "character")) { + .extraNames <- c(.extraNames, .ctl$omega) .mv <- rxModelVars(object) .col <- .ctl$omega .w <- .col %in% .mv$params @@ -1746,8 +1839,14 @@ rxSolve.default <- function(object, params = NULL, events = NULL, inits = NULL, if (length(.ignore)>0) { .minfo(paste0("sigma has too many items, ignored: '", paste(.ignore, collapse="', '"), "'")) } + .ctl$sigma <-.ctl$sigma[.w, .w, drop=FALSE] + if (dim(.ctl$sigma)[1] == 0) { + .ctl$sigma <- NULL + .ctl <- do.call(rxControl, .ctl) + } .names <- c(.names, .col[.w]) } else if ( inherits(.ctl$sigma, "character")) { + .extraNames <- c(.extraNames, .ctl$sigma) .mv <- rxModelVars(object) .col <- .ctl$sigma .w <- .col %in% .mv$params @@ -1757,6 +1856,36 @@ rxSolve.default <- function(object, params = NULL, events = NULL, inits = NULL, } .names <- c(.names, .col[.w]) } + + if (inherits(.ctl$thetaMat, "matrix")) { + .mv <- rxModelVars(object) + .col <- colnames(.ctl$thetaMat) + .w <- .col %in% c(.mv$params, .extraNames) + .ignore <- .col[!.w] + if (length(.ignore)>0) { + .minfo(paste0("thetaMat has too many items, ignored: '", paste(.ignore, collapse="', '"), "'")) + } + .ctl$thetaMat <-.ctl$thetaMat[.w, .w, drop=FALSE] + if (dim(.ctl$thetaMat)[1] == 0) { + .ctl$thetaMat <- NULL + .ctl <- do.call(rxControl, .ctl) + } + .names <- c(.names, .col[.w]) + + # now look for zero diagonals + .col <- colnames(.ctl$thetaMat) + .d <- diag(.ctl$thetaMat) + .w <- which(.d == 0) + if (length(.w) > 0) { + .minfo(paste0("thetaMat has zero diagonal items, ignored: '", paste(.col[.w], collapse="', '"), "'")) + .ctl$thetaMat <-.ctl$thetaMat[-.w, -.w, drop=FALSE] + if (dim(.ctl$thetaMat)[1] == 0) { + .ctl$thetaMat <- NULL + .ctl <- do.call(rxControl, .ctl) + } + .names <- c(.names, .col[-.w]) + } + } rxSetCovariateNamesForPiping(NULL) if (length(.ctl$.zeros) > 0) { if (rxIs(params, "rx.event")) { @@ -2200,3 +2329,65 @@ rxControlUpdateSens <- function(rxControl, sensCmt=NULL, ncmt=NULL) { rxControl$ssRtol <- c(rep(rxControl$ssRtol[1], ncmt - sensCmt), rep(rxControl$ssRtolSens, sensCmt)) rxControl } + + +#' rxUiDeparse.rxControl(rxControl(covsInterpolation="linear", method="dop853", +#' naInterpolation="nocb", keepInterpolation="nocb", sigmaXform="variance", +#' omegaXform="variance", returnType="data.frame", sumType="fsum", prodType="logify", +#' sensType="central"), "ctl") + +#' @rdname rxUiDeparse +#' @export +rxUiDeparse.rxControl <- function(object, var) { + .ret <- rxControl() + + .w <- which(vapply(names(.ret), function(x) { + if (is.integer(.ret[[x]]) && is.integer(object[[x]])) { + .ret[[x]] != object[[x]] + } else { + !identical(.ret[[x]], object[[x]]) + } + }, logical(1))) + + .retD <- vapply(names(.ret)[.w], function(x) { + if (x == "covsInterpolation") { + .covsInterpolation <- c("linear"=0L, "locf"=1L, "nocb"=2L, "midpoint"=3L) + paste0(x, " =", deparse1(names(.covsInterpolation)[which(object[[x]] == .covsInterpolation)])) + } else if (x == "method") { + .methodIdx <- c("lsoda" = 1L, "dop853" = 0L, "liblsoda" = 2L, "indLin" = 3L) + paste0(x, " =", deparse1(names(.methodIdx)[which(object[[x]] == .methodIdx)])) + } else if (x == "naInterpolation") { + .naInterpolation <- c("locf"=1L, "nocb"=0L) + paste0(x, " =", deparse1(names(.naInterpolation)[which(object[[x]] == .naInterpolation)])) + } else if (x == "keepInterpolation") { + .keepInterpolation <- c("locf"=1L, "nocb"=0L, "na"=2L) + paste0(x, " =", deparse1(names(.keepInterpolation)[which(object[[x]] == .keepInterpolation)])) + } else if (x %in% c("sigmaXform", "omegaXform")) { + .sigmaXform <- c( + "variance" = 6L, "log" = 5L, "identity" = 4L, + "nlmixrSqrt" = 1L, "nlmixrLog" = 2L, + "nlmixrIdentity" = 3L) + paste0(x, " =", deparse1(names(.sigmaXform)[which(object[[x]] == .sigmaXform)])) + } else if (x == "returnType") { + .matrixIdx <- c( + "rxSolve" = 0L, "matrix" = 1L, "data.frame" = 2L, "data.frame.TBS" = 3L, "data.table" = 4L, + "tbl" = 5L, "tibble" = 5L) + paste0(x, " =", deparse1(names(.matrixIdx)[which(object[[x]] == .matrixIdx)])) + } else if (x == "sumType") { + .sum <- c("pairwise"=1L, "fsum"=2L, "kahan"=3L , "neumaier"=4L, "c"=5L) + paste0(x, " = ", deparse1(names(.sum)[which(object[[x]] == .sum)])) + } else if (x == "prodType") { + .prod <- c("long double"=1L, "double"=1L, "logify"=1L) + paste0(x, " = ", deparse1(names(.prod)[which(object[[x]] == .prod)])) + } else if (x == "sensType") { + .sensType <- c("autodiff"=1L, "forward"=2L, "central"=3L, "advan"=4L) + paste0(x, " = ", deparse1(names(.sensType)[which(object[[x]] == .sensType)])) + } else if (x == "naTimeHandle") { + .naTimeHandle <- c("ignore"=1L, "warn"=2L, "error"=3L) + paste0(x, " = ", deparse1(names(.naTimeHandle)[which(object[[x]] == .naTimeHandle)])) + } else { + paste0(x, "=", deparse1(object[[x]])) + } + }, character(1), USE.NAMES=FALSE) + str2lang(paste(var, " <- rxControl(", paste(.retD, collapse=","),")")) +} diff --git a/R/symengine.R b/R/symengine.R index efc6829dd..5d918851e 100644 --- a/R/symengine.R +++ b/R/symengine.R @@ -571,28 +571,62 @@ rxToSE <- function(x, envir = NULL, progress = FALSE, return(.rxToSE(eval(parse(text = paste0("quote({", x, "})"))), envir, progress)) } +## adapted from URLencode +.rxStrEncode <- function (str) { + paste0("rxQ__", + vapply(str, function(str) { + OK <- "[^ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789]" + x <- strsplit(str, "")[[1L]] + z <- grep(OK, x) + if (length(z)) { + y <- vapply(x[z], function(x) + paste0("_", toupper(as.character(charToRaw(x))), + collapse = ""), "") + x[z] <- y + } + paste(x, collapse = "") + }, character(1), USE.NAMES = FALSE), + "__rxQ") +} + +.rxStrDecode <- function(x) { + .nchr <- nchar(x) + if (.nchr > 10) { + if (substr(x, 1, 5) == "rxQ__") { + .x <- charToRaw(substr(x, 6, .nchr - 5)) + .pc <- charToRaw("_") + .out <- raw(0L) + .i <- 1L + while (.i <= length(.x)) { + if (.x[.i] != .pc) { + .out <- c(.out, .x[.i]) + .i <- .i + 1L + } + else { + .y <- as.integer(.x[.i + 1L:2L]) + .y[.y > 96L] <- .y[.y > 96L] - 32L + .y[.y > 57L] <- .y[.y > 57L] - 7L + .y <- sum((.y - 48L) * c(16L, 1L)) + .out <- c(.out, as.raw(as.character(.y))) + .i <- .i + 3L + } + } + return(rawToChar(.out)) + } + } + return(x) +} + + .rxChrToSym <- function(x) { - str2lang(paste0( - "rxQ__", - gsub( - " ", "_rxSpace_", - gsub("[.]", "_rxDoT_", x) - ), - "__rxQ" - )) + str2lang(.rxStrEncode(x)) } .rxRepRxQ <- function(x) { .nchr <- nchar(x) if (.nchr > 10) { if (substr(x, 1, 5) == "rxQ__") { - return(deparse1(gsub( - "_rxSpace_", " ", - gsub( - "_rxDoT_", ".", - substr(x, 6, .nchr - 5) - ) - ))) + return(deparse1(.rxStrDecode(x))) } } return(x) @@ -1207,6 +1241,10 @@ rxToSE <- function(x, envir = NULL, progress = FALSE, } else if (identical(x[[1]], quote(`=`)) || identical(x[[1]], quote(`<-`)) || identical(x[[1]], quote(`~`))) { + if (length(x[[2]]) == 2 && + identical(x[[2]][[1]], quote(`levels`))) { + return("") + } return(.rxToSEAssignOperators(x, envir = envir, progress = progress, isEnv=isEnv)) } else if (identical(x[[1]], quote(`[`))) { return(.rxToSESquareBracket(x, envir = envir, progress = progress, isEnv=isEnv)) diff --git a/R/ui.R b/R/ui.R index 3e8cccd34..5c838daad 100644 --- a/R/ui.R +++ b/R/ui.R @@ -137,14 +137,17 @@ #' #' 'omega' values can be set as a single value or as the values of a #' lower-triangular matrix. The values may be set as either a -#' variance-covariance matrix (the default) or as a correlation matrix for the -#' off-diagonals with the standard deviations on the diagonals. Names may be -#' set on the left side of the \code{~}. To set a variance-covariance matrix -#' with variance values of 2 and 3 and a covariance of -2.5 use \code{~c(2, 2.5, -#' 3)}. To set the same matrix with names of \code{iivKa} and \code{iivCL}, use -#' \code{iivKa + iivCL~c(2, 2.5, 3)}. To set a correlation matrix with standard -#' deviations on the diagonal, use \code{cor()} like \code{iivKa + iivCL~cor(2, -#' -0.5, 3)}. +#' variance-covariance matrix (the default) or as a correlation matrix +#' for the off-diagonals with the standard deviations on the +#' diagonals. Names may be set on the left side of the \code{~}. To +#' set a variance-covariance matrix with variance values of 2 and 3 +#' and a covariance of -2.5 use \code{~c(2, 2.5, 3)}. To set the same +#' matrix with names of \code{iivKa} and \code{iivCL}, use \code{iivKa +#' + iivCL~c(2, 2.5, 3)}. To set a correlation matrix with standard +#' deviations on the diagonal, use \code{cor()} like \code{iivKa + +#' iivCL~cor(2, -0.5, 3)}. As of rxode2 3.0 you can also use +#' \code{iivKa ~ 2, iivCL ~ c(2.5, 3)} for covariance matrices as +#' well. #' #' Values may be fixed (and therefore not estimated) using either the name #' \code{fixed} at the end of the assignment or by calling \code{fixed()} as a @@ -173,6 +176,14 @@ #' has a label of "Typical Value of Clearance (L/hr)" is \code{tvCL <- 1; #' label("Typical Value of Clearance (L/hr)")}. #' +#' Off diagonal values of 'omega' can be set to zero using the +#' \code{diag()} to remove all off-diagonals can be removed with +#' `ini(diag())`. To remove covariances of 'omega' item with `iivKa`, +#' you can use `%>% ini(diag(iivKa))`. Or to remove covariances that +#' contain either `iivKa` or `iivCl` you can use `%>% ini(diag(iivKa, +#' iivCl))`. For finer control you can remove the covariance between +#' two items (like `iivKa` and `iivCl`) by `%>% ini(-cov(iivKa, iivCl)) +#' #' \code{rxode2}/\code{nlmixr2} will attempt to determine some #' back-transformations for the user. For example, \code{CL <- exp(tvCL)} will #' detect that \code{tvCL} must be back-transformed by \code{exp()} for easier @@ -226,7 +237,9 @@ #' @export ini <- function(x, ..., envir = parent.frame(), append = NULL) { if (is(substitute(x), "{")) { - .ini <- eval(bquote(lotri(.(substitute(x)))), envir=envir) + .ini <- eval(bquote(lotri::lotri(.(substitute(x)), + cov=TRUE, rcm=TRUE)), + envir=envir) assignInMyNamespace(".lastIni", .ini) assignInMyNamespace(".lastIniQ", bquote(.(substitute(x)))) return(invisible(.ini)) diff --git a/R/utils.R b/R/utils.R index d1de668ed..4e8090347 100644 --- a/R/utils.R +++ b/R/utils.R @@ -386,6 +386,67 @@ gammapInv <- function(a, p) { gammapInva <- function(x, p) { .Call(`_gammapInva`, x, p, PACKAGE = "rxode2") } +#' rxode2 general transformation function +#' +#' @param x value that will be transformed +#' @param lambda lambda value for the transformation +#' @param transform transformation to use (can be integer or string +#' matching supported transformations) +#' @param low lower bound for the transformation +#' @param high upper bound for the transformation +#' @param inverse boolean if the inverse transformation should be performed +#' @return transformed value +#' @export +#' @author Matthew L. Fidler +#' @keywords internal +#' @examples +#' +#' logit(0.25) +#' +#' .rxTransform(0.25, transform="logit") +#' +#' expit(-1.09) +#' +#' .rxTransform(-1.09, transform="logit", inverse=TRUE) +#' +.rxTransform <- function(x, lambda=1.0, + low = 0.0, high = 1.0, + transform=c("boxCox", "yeoJohnson", "untransformed", + "lnorm", "logit", "logit + yeoJohnson", + "probit", "probit + yeoJohnson", + "logit + boxCox", "probit + boxCox"), + inverse=FALSE) { + if (is.integer(transform)) { + } else { + transform <- factor(match.arg(transform), + levels=c("boxCox", "yeoJohnson", "untransformed", + "lnorm", "logit", "logit + yeoJohnson", + "probit", "probit + yeoJohnson", "logit + boxCox", + "probit + boxCox")) + transform <- as.integer(transform)-1L + } + if (length(lambda) > 1 || + length(low) > 1 || + length(high) > 1 || + length(transform) > 1 || + length(inverse) > 1) { + .df <- data.frame(x = x, lambda = lambda, low = low, high = high, + transform=transform, inverse=inverse) + vapply(1:nrow(.df), + function(i) { + .rxTransform(.df$x[i], .df$lambda[i], .df$low[i], .df$high[i], + .df$transform[i], .df$inverse[i]) + }, numeric(1), USE.NAMES = FALSE) + } else { + checkmate::assertNumeric(x, any.missing = FALSE) + checkmate::assertNumeric(lambda, any.missing = FALSE) + checkmate::assertNumeric(low, any.missing = FALSE) + checkmate::assertNumeric(high, any.missing = FALSE) + checkmate::assertInteger(transform, any.missing = FALSE) + checkmate::assertLogical(inverse, any.missing = FALSE) + .Call(`_rxode2_powerD`, x, low, high, lambda, transform, inverse) + } +} #' logit and inverse logit (expit) functions #' @@ -435,22 +496,27 @@ gammapInva <- function(x, p) { #' logitNormInfo(logit(0.25), sd = 0.1) #' #' logitNormInfo(logit(1, 0, 10), sd = 1, low = 0, high = 10) +#' #' @export logit <- function(x, low = 0, high = 1) { - .Call(`_logit`, x, low, high, PACKAGE = "rxode2") + .rxTransform(x, 1.0, low, high, 4L, FALSE) } #' @rdname logit #' @export expit <- function(alpha, low = 0, high = 1) { - .Call(`_expit`, alpha, low, high, PACKAGE = "rxode2") + .rxTransform(alpha, 1.0, low, high, 4L, TRUE) } #' @rdname logit #' @export logitNormInfo <- function(mean = 0, sd = 1, low = 0, high = 1, abs.tol = 1e-6, ...) { - .fM1 <- function(x) .Call(`_expit`, x, low, high, PACKAGE = "rxode2") * dnorm(x, mean = mean, sd = sd) + .fM1 <- function(x) { + expit(x, low, high) * dnorm(x, mean = mean, sd = sd) + } .m <- integrate(.fM1, -Inf, Inf, abs.tol = abs.tol, ...)$value - .fV <- function(x) (.Call(`_expit`, x, low, high, PACKAGE = "rxode2") - .m)^2 * dnorm(x, mean = mean, sd = sd) + .fV <- function(x){ + (expit(x, low, high) - .m)^2 * dnorm(x, mean = mean, sd = sd) + } .v <- integrate(.fV, -Inf, Inf, abs.tol = abs.tol, ...)$value c(mean = .m, var = .v, cv = sqrt(.v) / .m) } @@ -470,26 +536,61 @@ logitNormInfo <- function(mean = 0, sd = 1, low = 0, high = 1, abs.tol = 1e-6, . #' probitNormInfo(probit(1, 0, 10), sd = 1, low = 0, high = 10) #' @export probit <- function(x, low = 0, high = 1) { - .Call(`_probit`, x, low, high, PACKAGE = "rxode2") + .rxTransform(x, 1.0, low, high, 6L, FALSE) } #' @rdname probit #' @export probitInv <- function(x, low = 0, high = 1) { - .Call(`_probitInv`, x, low, high, PACKAGE = "rxode2") + .rxTransform(x, 1.0, low, high, 6L, TRUE) } #' @rdname logit #' @export probitNormInfo <- function(mean = 0, sd = 1, low = 0, high = 1, abs.tol = 1e-6, ...) { - .fM1 <- function(x) .Call(`_probitInv`, x, low, high, PACKAGE = "rxode2") * dnorm(x, mean = mean, sd = sd) + .fM1 <- function(x) probitInv(x, low, high) * dnorm(x, mean = mean, sd = sd) .m <- integrate(.fM1, -Inf, Inf, abs.tol = abs.tol, ...)$value - .fV <- function(x) (.Call(`_probitInv`, x, low, high, PACKAGE = "rxode2") - .m)^2 * dnorm(x, mean = mean, sd = sd) + .fV <- function(x) (probitInv(x, low, high) - .m)^2 * dnorm(x, mean = mean, sd = sd) .v <- integrate(.fV, -Inf, Inf, abs.tol = abs.tol, ...)$value c(mean = .m, var = .v, cv = sqrt(.v) / .m) } +#' boxCox/yeoJohnson and inverse boxCox/yeoJohnson functions +#' +#' @param x input value(s) to transform +#' @param lambda lambda value for the transformation +#' @return values from boxCox and boxCoxInv +#' @export +#' @examples +#' +#' boxCox(10, 0.5) +#' +#' boxCoxInv(4.32, 0.5) +#' +#' yeoJohnson(10, 0.5) +#' +#' yeoJohnsonInv(4.32, 0.5) +#' +boxCox <- function(x, lambda = 1.0) { + checkmate::assertNumeric(x, lower=0.0, any.missing=FALSE) + .rxTransform(x, lambda, low=0.0, high=1.0, 0L, FALSE) +} +#' @rdname boxCox +#' @export +boxCoxInv <- function(x, lambda = 1.0) { + .rxTransform(x, lambda, low=0.0, high=1.0, 0L, TRUE) +} +#' @rdname boxCox +#' @export +yeoJohnson <- function(x, lambda = 1.0) { + .rxTransform(x, lambda, low=0.0, high=1.0, 1L, FALSE) +} +#' @rdname boxCox +#' @export +yeoJohnsonInv <- function(x, lambda = 1.0) { + .rxTransform(x, lambda, low=0.0, high=1.0, 1L, TRUE) +} #' Get/Set the number of threads that rxode2 uses #' #' @param threads NULL (default) rereads environment variables. 0 diff --git a/_pkgdown.yml b/_pkgdown.yml index 1b958dd72..a4b51a1d3 100644 --- a/_pkgdown.yml +++ b/_pkgdown.yml @@ -33,25 +33,33 @@ reference: - rxCbindStudyIndividual - title: Functions for working with nlmixr2/rxode2 functions contents: + - as.ini + - as.model + - as.rxUi + - assertCompartmentExists + - assertCompartmentName + - assertCompartmentNew + - assertRxUi + - assertVariableExists + - assertVariableNew + - ini + - ini<- - model + - model<- - modelExtract - - ini - - zeroRe - - assertRxUi - rxAppendModel - rxFixPop - rxRename - - update.rxUi - - as.rxUi - - ini<- - - model<- - - rxode2<- - rxSetCovariateNamesForPiping - rxSetPipingAuto - - rxUiDecompress - rxUiCompress - - as.ini - - as.model + - rxUiDecompress + - rxode2<- + - testIniDf + - testRxLinCmt + - testRxUnbounded + - update.rxUi + - zeroRe - title: ggplot2/plot support functions contents: - stat_cens @@ -106,6 +114,7 @@ reference: - rxValidate - title: Special Functions for rxode2 contents: + - boxCox - erf - forderForceBase - gammap @@ -152,6 +161,18 @@ reference: - rxSymInvChol - swapMatListWithCube - uppergamma +- title: User functions + contents: + - linMod + - rxIntToBase + - rxIntToLetter + - rxUdfUiData + - rxUdfUiEst + - rxUdfUiIniDf + - rxUdfUiIniLhs + - rxUdfUiMv + - rxUdfUiNum + - rxUdfUiParsing - title: Internal Functions contents: - .cbindOme @@ -164,6 +185,7 @@ reference: - .rxLinCmtGen - .rxWithOptions - .rxWithWd + - .rxode2ptrs - .toClassicEvid - .vecDf - invWR1d @@ -212,6 +234,7 @@ reference: - rxode2parseGetPointerAssignment - rxode2parseGetTranslation - summary.rxode2 + - rxUiDeparse - title: Rxode2 data sets contents: - rxResidualError diff --git a/build/dual.R b/build/dual.R index d5938bcc9..e84d0ca67 100644 --- a/build/dual.R +++ b/build/dual.R @@ -116,7 +116,7 @@ toDual <- function(x="0.5*(s - sqrt(s*s - 4*(*k32)*(*k20)))"){ print(x[[1]]) print(x) } - return(as.call(lapply(x, f))); + return(as.call(lapply(x, f))) } } return(gsub(" +", "", deparse1(f(eval(parse(text=paste0("quote(", fromC(x), ")"))))))) diff --git a/build/sensitivites.R b/build/sensitivites.R index a3f65add5..d95510197 100644 --- a/build/sensitivites.R +++ b/build/sensitivites.R @@ -64,7 +64,7 @@ toC <- function(x, doOpt=TRUE) { } else if (any(deparse1(x[[1]]) == .fun)) { return(x[[1]]) } - return(as.call(lapply(x, f))); + return(as.call(lapply(x, f))) } else { stop("Don't know how to handle type ", typeof(x), call. = FALSE) @@ -392,7 +392,7 @@ f <- function(x){ } stop("^") } - return(as.call(lapply(x, f))); + return(as.call(lapply(x, f))) } else { stop("Don't know how to handle type ", typeof(x), call. = FALSE) diff --git a/cran-comments.md b/cran-comments.md index e571507d3..3ec97fba7 100644 --- a/cran-comments.md +++ b/cran-comments.md @@ -1,5 +1,19 @@ -- This works with the new rxode2 parse -- This is more pendantic with the no-remap so that no-remap is everywhere :) -- This moves the ignored steady state indicators to a allocated - integer so garbage collection will not cause gcc-USBAN alignment - errors + +- Bug fix for `api`, the censoring function pointer has been updated + (#801). + +- Query `rxode2.verbose.pipe` at run time instead of requiring it to + be set before loading `rxode2`. + +- Have correct values at boundaries for `logit`, `expit`, `probit`, + and `probitInv` (instead of `NA`). For most cases this does not + break anything. + +- Add a new style of user function that modifies the `ui` while + parsing or just before using the function (in the presence of + `data`). + +- Used the new user function interface to allow all random functions + in `rxode2` ui functions to be named. For example, you can use + `rxnorm(sd=3)` instead of having to use `rxnorm(0, 3)`, although + `rxnorm()` still works. diff --git a/inst/CITATION b/inst/CITATION index 2fc066920..642ab2615 100644 --- a/inst/CITATION +++ b/inst/CITATION @@ -26,5 +26,4 @@ bibentry(bibtype="Article", abstract = "This tutorial presents the application of an R package, RxODE, that facilitates quick, efficient simulations of ordinary differential equation models completely within R. Its application is illustrated through simulation of design decision effects on an adaptive dosing regimen. The package provides an efficient, versatile way to specify dosing scenarios and to perform simulation with variability with minimal custom coding. Models can be directly translated to Rshiny applications to facilitate interactive, real-time evaluation/iteration on simulation scenarios.", address ="Hoboken", issn = "2163-8306", - publisher = "John Wiley and Sons Inc.", - url = "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4728294/") + publisher = "John Wiley and Sons Inc.") diff --git a/inst/include/rxode2.h b/inst/include/rxode2.h index 634224a8f..c5102d384 100644 --- a/inst/include/rxode2.h +++ b/inst/include/rxode2.h @@ -26,8 +26,11 @@ #include "rxode2_control.h" #include // for uint64_t rather than unsigned long long + +#ifndef __RXODE2PTR_H__ // directly refer to abi need to be excluded #define getAdvan(idx) ind->solve + (op->neq + op->nlin)*(idx) + op->neq #define getSolve(idx) ind->solve + (op->neq + op->nlin)*(idx) +#endif #ifdef _isrxode2_ #define min2( a , b ) ( (a) < (b) ? (a) : (b) ) @@ -69,15 +72,20 @@ typedef int (*t_dydt_liblsoda)(double t, double *y, double *ydot, void *data); typedef void (*t_ode_current)(void); typedef void (*t_set_solve)(rx_solve *); + typedef rx_solve *(*t_get_solve)(void); typedef void *(*t_assignFuns)(void); +#ifndef __RXODE2PTR_H__ rx_solve *getRxSolve_(void); +#endif rx_solve *getRxSolve2_(void); rx_solve *getRxSolve(SEXP ptr); +#ifndef __RXODE2PTR_H__ void par_solve(rx_solve *rx); +#endif rx_solving_options *getRxOp(rx_solve *rx); diff --git a/inst/include/rxode2_control.h b/inst/include/rxode2_control.h index f0d18d1d4..a70c99522 100644 --- a/inst/include/rxode2_control.h +++ b/inst/include/rxode2_control.h @@ -97,5 +97,8 @@ #define Rxc_ssAtDoseTime 92 #define Rxc_ss2cancelAllPending 93 #define Rxc_naInterpolation 94 -#define Rxc__zeros 95 +#define Rxc_keepInterpolation 95 +#define Rxc_safeLog 96 +#define Rxc_safePow 97 +#define Rxc__zeros 98 #endif // __rxode2_control_H__ diff --git a/inst/include/rxode2_model_shared.c b/inst/include/rxode2_model_shared.c index acb668e2b..95f642cb1 100644 --- a/inst/include/rxode2_model_shared.c +++ b/inst/include/rxode2_model_shared.c @@ -137,6 +137,7 @@ double _prod(double *input, double *p, int type, int n, ...){ } double _udf(const char *funName, double *input, int n, ...) { + if (n == -42) Rf_error("%s", "this has a ui user function that cannot be called directly"); va_list valist; va_start(valist, n); for (unsigned int i = 0; i < n; i++){ diff --git a/inst/include/rxode2_model_shared.h b/inst/include/rxode2_model_shared.h index f56bd992a..f20f921a6 100644 --- a/inst/include/rxode2_model_shared.h +++ b/inst/include/rxode2_model_shared.h @@ -6,20 +6,57 @@ #define _evid getEvid((&_solveData->subjects[_cSub]), (&_solveData->subjects[_cSub])->ix[(&_solveData->subjects[_cSub])->idx]) #define amt (isDose(_evid) ? getDose((&_solveData->subjects[_cSub]),(&_solveData->subjects[_cSub])->ixds) : NA_REAL) #define JAC_Rprintf Rprintf -#define _idx (&_solveData->subjects[_cSub])->idx -#define JAC0_Rprintf if ( (&_solveData->subjects[_cSub])->jac_counter == 0) Rprintf +#define _idx (_solveData->subjects[_cSub]).idx +#define JAC0_Rprintf if ((_solveData->subjects[_cSub]).jac_counter == 0) Rprintf #define ODE_Rprintf Rprintf -#define ODE0_Rprintf if ( (&_solveData->subjects[_cSub])->dadt_counter == 0) Rprintf +#define ODE0_Rprintf if ((_solveData->subjects[_cSub]).dadt_counter == 0) Rprintf #define LHS_Rprintf Rprintf -#define _safe_log(a) (&_solveData->safeZero ? (((a) <= 0) ? log(DBL_EPSILON) : log(a)) : log(a)) -#define safe_zero(a) (&_solveData->safeZero ? ((a) == 0 ? DBL_EPSILON : ((double)(a))) : ((double)(a))) -#define _as_zero(a) (&_solveData->safeZero && fabs((double)(a)) < sqrt(DBL_EPSILON) ? 0.0 : ((double)(a))) -#define _as_dbleps(a) (&_solveData->safeZero && fabs((double)a) < sqrt(DBL_EPSILON) ? (((double)(a)) < 0 ? -sqrt(DBL_EPSILON) : sqrt(DBL_EPSILON)) : ((double)(a))) -#define _as_dbleps2(a) (&_solveData->safeZero && fabs((double)(a)) < sqrt(DBL_EPSILON) ? sqrt(DBL_EPSILON) : ((double)(a))) +static inline double _safe_log_(double a, rx_solve *rx) { + if (rx->safeLog) { + return (a <= 0) ? log(DBL_EPSILON) : log(a); + } else { + return log(a); + } +} +#define _safe_log(a) _safe_log_(a, _solveData) +static inline double _div0_(double denom, rx_solve *rx) { + if (rx->safeZero) { + return (denom == 0.0) ? DBL_EPSILON : denom; + } else { + return denom; + } +} +#define _div0(a) _div0_(a, _solveData) #define factorial(a) exp(lgamma1p(a)) #define sign_exp(sgn, x)(((sgn) > 0.0) ? exp(x) : (((sgn) < 0.0) ? -exp(x) : 0.0)) -#define Rx_pow(a, b) (&_solveData->useStdPow ? pow(a, b) : R_pow(a, b)) -#define Rx_pow_di(a, b) (&_solveData->useStdPow ? pow(a, b) : R_pow_di(a, b)) +static inline double Rx_pow_(double a, double b, rx_solve *rx) { + double a0 = a; + if (rx->safePow) { + if (b < 0 && a == 0.0) { + a0 = DBL_EPSILON; + } + } + if (rx->useStdPow) { + return pow(a0, b); + } else { + return R_pow(a0, b); + } +} +#define Rx_pow(a, b) Rx_pow_(a, b, _solveData) +static inline double Rx_pow_di_(double a, double b, rx_solve *rx) { + double a0 = a; + if (rx->safePow) { + if (b < 0 && a == 0.0) { + a0 = DBL_EPSILON; + } + } + if (rx->useStdPow) { + return pow(a0, b); + } else { + return R_pow_di(a0, (int)b); + } +} +#define Rx_pow_di(a, b) Rx_pow_di_(a, b, _solveData) #define abs_log1p(x) (((x) + 1.0 > 0.0) ? log1p(x) : (((x) + 1.0 > 0.0) ? log1p(-x) : 0.0)) #define abs_log(x) ((&_solveData->safeZero && fabs(x) <= sqrt(DBL_EPSILON)) ? log(sqrt(DBL_EPSILON)) : (((x) > 0.0) ? log(x) ? (((x) == 0) ? 0.0 : log(-x)))) #define _IR (_solveData->subjects[_cSub].InfusionRate) diff --git a/inst/include/rxode2parse.h b/inst/include/rxode2parse.h index bcd93d5ad..3319607bd 100644 --- a/inst/include/rxode2parse.h +++ b/inst/include/rxode2parse.h @@ -4,11 +4,16 @@ #define __rxode2parse_H__ #define rxLlikSaveSize 9 +#ifndef __RXODE2PTR_H__ // these refer to abi and should not be used. #define getAdvan(idx) ind->solve + (op->neq + op->nlin)*(idx) + op->neq #define getSolve(idx) ind->solve + (op->neq + op->nlin)*(idx) +#endif // __RXODE2PTR_H__ + + #define isDose(evid) ((evid) == 3 || (evid) >= 100) #define isObs(evid) ((evid) == 0 || (evid) == 2 || ((evid) >= 9 && (evid) <= 99)) +#ifndef __RXODE2PTR_H__ // these refer to abi and should not be used. #define getEvid(ind, idx) (idx >= 0 ? ind->evid[idx] : ind->extraDoseEvid[-1-idx]) #define getEvidP1(ind, idx) (idx >= 0 ? ind->evid[idx+1] : ind->extraDoseEvid[-idx]) #define getEvidM1(ind, idx) (idx >= 0 ? ind->evid[idx-1] : ind->extraDoseEvid[-2-idx]) @@ -30,6 +35,8 @@ #define getAllTimesM1(ind, idx) (idx >= 0 ? ind->all_times[idx-1] : ind->extraDoseTime[-2-idx]) #define setAllTimesP1(ind, idx, val) if (idx>= 0) {ind->all_times[idx+1] = val;} else {ind->extraDoseTime[-idx] = val;} +#endif // __RXODE2PTR_H__ + #include #include diff --git a/inst/include/rxode2parseStruct.h b/inst/include/rxode2parseStruct.h index f8af86c19..4aaac2be8 100644 --- a/inst/include/rxode2parseStruct.h +++ b/inst/include/rxode2parseStruct.h @@ -41,6 +41,7 @@ typedef struct { char modNamePtr[1000]; int *par_cov; int *par_cov_interp; + int *lhs_str; double *inits; double *scale; @@ -48,6 +49,7 @@ typedef struct { // approx fun options int is_locf; int instant_backward; + int keep_interp; int cores; int doesRandom; int extraCmt; @@ -246,6 +248,8 @@ typedef struct { int cens; int limit; int safeZero; + int safeLog; + int safePow; int sumType; int prodType; int sensType; @@ -268,6 +272,7 @@ typedef struct { int hasEvid2; int useStdPow; bool ss2cancelAllPending; + int npars; } rx_solve; diff --git a/inst/include/rxode2parse_control.h b/inst/include/rxode2parse_control.h index 51fa0e328..9566d5bbc 100644 --- a/inst/include/rxode2parse_control.h +++ b/inst/include/rxode2parse_control.h @@ -96,7 +96,10 @@ #define Rxc_ssAtDoseTime 92 #define Rxc_ss2cancelAllPending 93 #define Rxc_naInterpolation 94 -#define Rxc__zeros 95 +#define Rxc_keepInterpolation 95 +#define Rxc_safeLog 96 +#define Rxc_safePow 97 +#define Rxc__zeros 98 #define RxMv_params 0 #define RxMv_lhs 1 #define RxMv_state 2 @@ -119,8 +122,14 @@ #define RxMv_alag 19 #define RxMv_udf 20 #define RxMv_interp 21 -#define RxMv_timeId 22 -#define RxMv_md5 23 +#define RxMv_strAssign 22 +#define RxMv_lhsStr 23 +#define RxMv_stateProp 24 +#define RxMv_sensProp 25 +#define RxMv_normProp 26 +#define RxMv_stateOrd 27 +#define RxMv_timeId 28 +#define RxMv_md5 29 #define RxMvFlag_ncmt 0 #define RxMvFlag_ka 1 #define RxMvFlag_linB 2 diff --git a/inst/include/rxode2ptr.h b/inst/include/rxode2ptr.h new file mode 100644 index 000000000..6821db274 --- /dev/null +++ b/inst/include/rxode2ptr.h @@ -0,0 +1,278 @@ +#ifndef __RXODE2PTR_H__ +#define __RXODE2PTR_H__ + +#include "rxode2.h" + +#if defined(__cplusplus) +extern "C" { +#endif + + typedef SEXP (*_rxode2_rxRmvnSEXP_t)(SEXP nSSEXP, SEXP muSSEXP, SEXP sigmaSSEXP, SEXP lowerSSEXP, SEXP upperSSEXP, SEXP ncoresSSEXP, SEXP isCholSSEXP, SEXP keepNamesSSEXP, SEXP aSSEXP, SEXP tolSSEXP, SEXP nlTolSSEXP, SEXP nlMaxiterSSEXP); + extern _rxode2_rxRmvnSEXP_t _rxode2_rxRmvnSEXP_; + + typedef int (*par_progress_t)(int c, int n, int d, int cores, clock_t t0, int stop); + extern par_progress_t par_progress; + + typedef rx_solve *(*getRxSolve_t)(void); + extern getRxSolve_t getRxSolve_; + + typedef void (*ind_solve_t)(rx_solve *rx, unsigned int cid, t_dydt_liblsoda dydt_lls, + t_dydt_lsoda_dum dydt_lsoda, t_jdum_lsoda jdum, + t_dydt c_dydt, t_update_inis u_inis, int jt); + extern ind_solve_t ind_solve; + + typedef double (*getTime_t)(int idx, rx_solving_options_ind *ind); + extern getTime_t getTime; + + typedef int (*isRstudio_t)(void); + extern isRstudio_t isRstudio; + + typedef int (*iniSubjectE_t)(int solveid, int inLhs, rx_solving_options_ind *ind, rx_solving_options *op, rx_solve *rx, + t_update_inis u_inis); + extern iniSubjectE_t iniSubjectE; + + typedef void (*sortIds_t)(rx_solve* rx, int ini); + extern sortIds_t sortIds; + + typedef rx_solving_options* (*getSolvingOptions_t)(rx_solve* rx); + extern getSolvingOptions_t getSolvingOptions; + + typedef rx_solving_options_ind *(*getSolvingOptionsInd_t)(rx_solve *rx, int id); + extern getSolvingOptionsInd_t getSolvingOptionsInd; + + typedef SEXP (*_rxode2_rxModelVars_t)(SEXP); + extern _rxode2_rxModelVars_t _rxode2_rxModelVars_; + + typedef void (*par_solve_t)(rx_solve *rx); + extern par_solve_t par_solve; + + typedef const char *(*rxGetId_t)(int id); + extern rxGetId_t rxGetId; + + typedef double (*getIndLambda_t)(rx_solving_options_ind* ind); + extern getIndLambda_t getIndLambda; + + typedef int (*getIndLambdaYj_t)(rx_solving_options_ind* ind); + extern getIndLambdaYj_t getIndLambdaYj; + + typedef double (*getIndLogitLow_t)(rx_solving_options_ind* ind); + extern getIndLogitLow_t getIndLogitLow; + + typedef double (*getIndLogitHi_t)(rx_solving_options_ind* ind); + extern getIndLogitHi_t getIndLogitHi; + + typedef void (*setIndParPtr_t)(rx_solving_options_ind* ind, int i, double val); + extern setIndParPtr_t setIndParPtr; + + typedef double (*getIndParPtr_t)(rx_solving_options_ind* ind, int i); + extern getIndParPtr_t getIndParPtr; + + typedef int (*getIndNallTimes_t)(rx_solving_options_ind* ind); + extern getIndNallTimes_t getIndNallTimes; + + typedef void (*setIndIdx_t)(rx_solving_options_ind* ind, int j); + extern setIndIdx_t setIndIdx; + + typedef int (*getIndIx_t)(rx_solving_options_ind* ind, int j); + extern getIndIx_t getIndIx; + + typedef int (*getIndEvid_t)(rx_solving_options_ind* ind, int kk); + extern getIndEvid_t getIndEvid; + + typedef double *(*getIndLhs_t)(rx_solving_options_ind* ind); + extern getIndLhs_t getIndLhs; + + typedef int (*getIndNdoses_t)(rx_solving_options_ind* ind); + extern getIndNdoses_t getIndNdoses; + + typedef int (*getIndNevid2_t)(rx_solving_options_ind* ind); + extern getIndNevid2_t getIndNevid2; + + typedef void (*setIndSolve_t)(rx_solving_options_ind* ind, int solve); + extern setIndSolve_t setIndSolve; + + typedef double *(*getIndSolve_t)(rx_solving_options_ind* ind); + extern getIndSolve_t getIndSolve; + + typedef double (*getIndDv_t)(rx_solving_options_ind* ind, int j); + extern getIndDv_t getIndDv; + + typedef int (*getIndYj_t)(rx_solving_options_ind* ind); + extern getIndYj_t getIndYj; + + typedef double (*getIndLimit_t)(rx_solving_options_ind* ind, int kk); + extern getIndLimit_t getIndLimit; + + typedef int (*getIndCens_t)(rx_solving_options_ind* ind, int kk); + extern getIndCens_t getIndCens; + + typedef int (*getIndIdx_t)(rx_solving_options_ind* ind); + extern getIndIdx_t getIndIdx; + + typedef int (*getOpNeq_t)(rx_solving_options* op); + extern getOpNeq_t getOpNeq; + +#define getRxNeq(rx) getOpNeq(getSolvingOptions(rx)) + + typedef void (*setOpNeq_t)(rx_solving_options* op, int neq); + extern setOpNeq_t setOpNeq; + +#define setRxNeq(rx, neq) setOpNeq(getSolvingOptions(rx), neq) + + typedef int (*hasOpBadSolve_t)(rx_solving_options* op); + extern hasOpBadSolve_t hasOpBadSolve; +#define hasRxBadSolve(rx) hasOpBadSolve(getSolvingOptions(rx)) + + typedef int (*getOpNlin_t)(rx_solving_options* op); + extern getOpNlin_t getOpNlin; +#define getRxNlin(rx) getOpNlin(getSolvingOptions(rx)) + + typedef int (*getOpCores_t)(rx_solving_options* op); + extern getOpCores_t getOpCores; +#define getRxCores(rx) getOpCores(getSolvingOptions(rx)) + + typedef int (*getOpNlhs_t)(rx_solving_options* op); + extern getOpNlhs_t getOpNlhs; +#define getRxNlhs(rx) getOpNlhs(getSolvingOptions(rx)) + + typedef int (*getOpStiff_t)(rx_solving_options* op); + extern getOpStiff_t getOpStiff; +#define getRxStiff(rx) getOpStiff(getSolvingOptions(rx)) + + typedef void (*resetOpBadSolve_t)(rx_solving_options* op); + extern resetOpBadSolve_t resetOpBadSolve; +#define resetRxBadSolve(rx) resetOpBadSolve(getSolvingOptions(rx)) + + typedef int (*getRxNsub_t)(rx_solve *rx); + extern getRxNsub_t getRxNsub; + + typedef int (*hasRxLimit_t)(rx_solve *rx); + extern hasRxLimit_t hasRxLimit; + + typedef int (*hasRxCens_t)(rx_solve *rx); + extern hasRxCens_t hasRxCens; + + typedef int (*getRxNall_t)(rx_solve *rx); + extern getRxNall_t getRxNall; + + typedef int (*getRxNobs_t)(rx_solve *rx); + extern getRxNobs_t getRxNobs; + + typedef int (*getRxNobs2_t)(rx_solve *rx); + extern getRxNobs2_t getRxNobs2; + + typedef double * (*getOpIndSolve_t)(rx_solving_options* op, rx_solving_options_ind* ind, int idx); + extern getOpIndSolve_t getOpIndSolve; + + static inline SEXP iniRxodePtrs0(SEXP p) { + if (_rxode2_rxRmvnSEXP_ == NULL) { + _rxode2_rxRmvnSEXP_ = (_rxode2_rxRmvnSEXP_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 0)); + par_progress = (par_progress_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 1)); + getRxSolve_ = (getRxSolve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 2)); + ind_solve = (ind_solve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 3)); + getTime = (getTime_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 4)); + isRstudio = (isRstudio_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 5)); + iniSubjectE = (iniSubjectE_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 6)); + sortIds = (sortIds_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 7)); + getSolvingOptions = (getSolvingOptions_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 8)); + getSolvingOptionsInd = (getSolvingOptionsInd_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 9)); + _rxode2_rxModelVars_ = (_rxode2_rxModelVars_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 10)); + par_solve = (par_solve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 11)); + rxGetId = (rxGetId_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 12)); + getIndLambda = (getIndLambda_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 13)); + getIndLambdaYj = (getIndLambdaYj_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 14)); + getIndLogitLow = (getIndLogitLow_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 15)); + getIndLogitHi = (getIndLogitHi_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 16)); + setIndParPtr = (setIndParPtr_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 17)); + getIndParPtr = (getIndParPtr_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 18)); + getIndNallTimes = (getIndNallTimes_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 19)); + setIndIdx = (setIndIdx_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 20)); + getIndIx = (getIndIx_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 21)); + getIndEvid= (getIndEvid_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 22)); + getIndLhs = (getIndLhs_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 23)); + getIndNdoses = (getIndNdoses_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 24)); + getIndNevid2 = (getIndNevid2_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 25)); + setIndSolve = (setIndSolve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 26)); + getIndSolve = (getIndSolve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 27)); + getIndDv = (getIndDv_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 28)); + getIndYj = (getIndYj_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 29)); + getIndLimit = (getIndLimit_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 30)); + getIndCens = (getIndCens_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 31)); + getIndIdx = (getIndIdx_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 32)); + getOpNeq = (getOpNeq_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 33)); + setOpNeq= (setOpNeq_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 34)); + hasOpBadSolve = (hasOpBadSolve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 35)); + getOpNlin = (getOpNlin_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 36)); + getOpCores = (getOpCores_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 37)); + getOpNlhs = (getOpNlhs_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 38)); + getOpStiff = (getOpStiff_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 39)); + resetOpBadSolve = (resetOpBadSolve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 40)); + getRxNsub = (getRxNsub_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 41)); + hasRxLimit = (hasRxLimit_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 42)); + hasRxCens = (hasRxCens_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 43)); + getRxNall = (getRxNall_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 44)); + getRxNobs = (getRxNobs_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 45)); + getRxNobs2 = (getRxNobs2_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 46)); + getOpIndSolve = (getOpIndSolve_t) R_ExternalPtrAddrFn(VECTOR_ELT(p, 47)); + } + return R_NilValue; + } + +#define iniRxode2ptr \ + _rxode2_rxRmvnSEXP_t _rxode2_rxRmvnSEXP_ = NULL; \ + par_progress_t par_progress = NULL; \ + getRxSolve_t getRxSolve_ = NULL; \ + ind_solve_t ind_solve = NULL; \ + par_solve_t par_solve = NULL; \ + getTime_t getTime = NULL; \ + isRstudio_t isRstudio = NULL; \ + iniSubjectE_t iniSubjectE = NULL; \ + sortIds_t sortIds = NULL; \ + getSolvingOptions_t getSolvingOptions = NULL; \ + getSolvingOptionsInd_t getSolvingOptionsInd = NULL; \ + _rxode2_rxModelVars_t _rxode2_rxModelVars_ = NULL; \ + getIndLambda_t getIndLambda = NULL; \ + getIndLambdaYj_t getIndLambdaYj = NULL; \ + getIndLogitLow_t getIndLogitLow = NULL; \ + getIndLogitHi_t getIndLogitHi = NULL; \ + rxGetId_t rxGetId = NULL; \ + setIndParPtr_t setIndParPtr = NULL; \ + getIndParPtr_t getIndParPtr = NULL; \ + getIndNallTimes_t getIndNallTimes = NULL; \ + setIndIdx_t setIndIdx = NULL; \ + getIndIx_t getIndIx = NULL; \ + getIndEvid_t getIndEvid = NULL; \ + getIndLhs_t getIndLhs = NULL; \ + getIndNdoses_t getIndNdoses = NULL; \ + getIndNevid2_t getIndNevid2 = NULL; \ + setIndSolve_t setIndSolve = NULL; \ + getIndSolve_t getIndSolve = NULL; \ + getIndDv_t getIndDv = NULL; \ + getIndYj_t getIndYj = NULL; \ + getIndLimit_t getIndLimit = NULL; \ + getIndCens_t getIndCens = NULL; \ + getIndIdx_t getIndIdx = NULL; \ + getOpNeq_t getOpNeq = NULL; \ + setOpNeq_t setOpNeq = NULL; \ + hasOpBadSolve_t hasOpBadSolve = NULL; \ + getOpNlin_t getOpNlin = NULL; \ + getOpCores_t getOpCores = NULL; \ + getOpNlhs_t getOpNlhs = NULL; \ + getOpStiff_t getOpStiff = NULL; \ + resetOpBadSolve_t resetOpBadSolve = NULL; \ + getRxNsub_t getRxNsub = NULL; \ + hasRxLimit_t hasRxLimit = NULL; \ + hasRxCens_t hasRxCens = NULL; \ + getRxNall_t getRxNall = NULL; \ + getRxNobs_t getRxNobs = NULL; \ + getRxNobs2_t getRxNobs2 = NULL; \ + getOpIndSolve_t getOpIndSolve = NULL; \ + SEXP iniRxodePtrs(SEXP ptr) { \ + return iniRxodePtrs0(ptr); \ + } \ + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/inst/tran.g b/inst/tran.g index aba0b4368..abe96c293 100644 --- a/inst/tran.g +++ b/inst/tran.g @@ -3,6 +3,9 @@ statement_list : (statement)+ ; statement : assignment end_statement + | assign_str end_statement + | levels_str end_statement + | levels_str1 end_statement | ini end_statement | ini0 end_statement | ini0f end_statement @@ -83,6 +86,14 @@ end_statement : (';')* ; assignment : identifier_r ('=' | '<-' | '~' ) logical_or_expression; +assign_str : identifier_r_no_output ('=' | '<-' | '~' ) string; + +levels_str : 'levels' '(' identifier_r_no_output ')' ('=' | '<-' | '~' ) + 'c' '(' string ( ',' string)* ')'; + +levels_str1 : 'levels' '(' identifier_r_no_output ')' ('=' | '<-' | '~' ) + string ; + mat0: '_rxM' '=' logical_or_expression; matF: '_rxF' '=' logical_or_expression; @@ -174,7 +185,9 @@ theta0_noout: ('THETA' | 'theta' | 'ETA' | 'eta'); decimalintNo0: "([1-9][0-9]*)" $term -1; decimalint: "0|([1-9][0-9]*)" $term -1; -string: "\"([^\"\\]|\\[^])*\""; +string: string1 | string2; +string1: "\"([^\"\\]|\\[^])*\""; +string2: "'([^'\\]|\\[^])*'"; float1: "([0-9]+.[0-9]*|[0-9]*.[0-9]+)([eE][\-\+]?[0-9]+)?" $term -2; float2: "[0-9]+[eE][\-\+]?[0-9]+" $term -3; identifier_r_1: "[a-zA-Z][a-zA-Z0-9_.]*" $term -4; diff --git a/man-roxygen/etExamples.R b/man-roxygen/etExamples.R index e83824d24..0fbca20b5 100644 --- a/man-roxygen/etExamples.R +++ b/man-roxygen/etExamples.R @@ -1,6 +1,6 @@ #' @examples #' -#' \donttest{ +#' \dontrun{ #' #' library(rxode2) #' library(units) @@ -32,16 +32,17 @@ #' ## These are making the more complex regimens of the rxode2 tutorial #' #' ## bid for 5 days -#' bid <- et(timeUnits="hr") %>% +#' bid <- et(timeUnits="hr") |> #' et(amt=10000,ii=12,until=set_units(5, "days")) #' #' ## qd for 5 days -#' qd <- et(timeUnits="hr") %>% +#' qd <- et(timeUnits="hr") |> #' et(amt=20000,ii=24,until=set_units(5, "days")) #' #' ## bid for 5 days followed by qd for 5 days #' -#' et <- seq(bid,qd) %>% et(seq(0,11*24,length.out=100)) +#' et <- seq(bid,qd) |> +#' et(seq(0,11*24,length.out=100)) #' #' bidQd <- rxSolve(mod1, et) #' @@ -51,11 +52,12 @@ #' ## Now Infusion for 5 days followed by oral for 5 days #' #' ## note you can dose to a named compartment instead of using the compartment number -#' infusion <- et(timeUnits = "hr") %>% +#' infusion <- et(timeUnits = "hr") |> #' et(amt=10000, rate=5000, ii=24, until=set_units(5, "days"), cmt="centr") #' #' -#' qd <- et(timeUnits = "hr") %>% et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") +#' qd <- et(timeUnits = "hr") |> +#' et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") #' #' et <- seq(infusion,qd) #' @@ -65,9 +67,10 @@ #' #' ## 2wk-on, 1wk-off #' -#' qd <- et(timeUnits = "hr") %>% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +#' qd <- et(timeUnits = "hr") |> +#' et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") #' -#' et <- seq(qd, set_units(1,"weeks"), qd) %>% +#' et <- seq(qd, set_units(1,"weeks"), qd) |> #' add.sampling(set_units(seq(0, 5.5,by=0.005),weeks)) #' #' wkOnOff <- rxSolve(mod1, et) @@ -76,10 +79,11 @@ #' #' ## You can also repeat the cycle easily with the rep function #' -#' qd <-et(timeUnits = "hr") %>% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +#' qd <-et(timeUnits = "hr") |> +#' et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") #' -#' et <- etRep(qd, times=4, wait=set_units(1,"weeks")) %>% -#' add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) +#' et <- etRep(qd, times=4, wait=set_units(1,"weeks")) |> +#' add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) #' #' repCycle4 <- rxSolve(mod1, et) #' @@ -97,6 +101,5 @@ #' #' Wang W, Hallow K, James D (2015). "A Tutorial on rxode2: Simulating #' Differential Equation Pharmacometric Models in R." CPT: -#' Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306, -#' . +#' Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306 #' diff --git a/man/add.dosing.Rd b/man/add.dosing.Rd index a58a7d70f..1f08bf4c9 100644 --- a/man/add.dosing.Rd +++ b/man/add.dosing.Rd @@ -60,7 +60,7 @@ piping syntax through magrittr. It can also be accessed by \code{eventTable$add } \examples{ -\donttest{ +\dontrun{ library(rxode2) library(units) @@ -92,16 +92,17 @@ mod1 <-function(){ ## These are making the more complex regimens of the rxode2 tutorial ## bid for 5 days -bid <- et(timeUnits="hr") \%>\% +bid <- et(timeUnits="hr") |> et(amt=10000,ii=12,until=set_units(5, "days")) ## qd for 5 days -qd <- et(timeUnits="hr") \%>\% +qd <- et(timeUnits="hr") |> et(amt=20000,ii=24,until=set_units(5, "days")) ## bid for 5 days followed by qd for 5 days -et <- seq(bid,qd) \%>\% et(seq(0,11*24,length.out=100)) +et <- seq(bid,qd) |> + et(seq(0,11*24,length.out=100)) bidQd <- rxSolve(mod1, et) @@ -111,11 +112,12 @@ plot(bidQd, C2) ## Now Infusion for 5 days followed by oral for 5 days ## note you can dose to a named compartment instead of using the compartment number -infusion <- et(timeUnits = "hr") \%>\% +infusion <- et(timeUnits = "hr") |> et(amt=10000, rate=5000, ii=24, until=set_units(5, "days"), cmt="centr") -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") et <- seq(infusion,qd) @@ -125,9 +127,10 @@ plot(infusionQd, C2) ## 2wk-on, 1wk-off -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- seq(qd, set_units(1,"weeks"), qd) \%>\% +et <- seq(qd, set_units(1,"weeks"), qd) |> add.sampling(set_units(seq(0, 5.5,by=0.005),weeks)) wkOnOff <- rxSolve(mod1, et) @@ -136,10 +139,11 @@ plot(wkOnOff, C2) ## You can also repeat the cycle easily with the rep function -qd <-et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <-et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- etRep(qd, times=4, wait=set_units(1,"weeks")) \%>\% - add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) +et <- etRep(qd, times=4, wait=set_units(1,"weeks")) |> + add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) repCycle4 <- rxSolve(mod1, et) @@ -150,8 +154,7 @@ plot(repCycle4, C2) \references{ Wang W, Hallow K, James D (2015). "A Tutorial on rxode2: Simulating Differential Equation Pharmacometric Models in R." CPT: -Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306, -. +Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306 } \seealso{ \code{\link{eventTable}}, \code{\link{add.sampling}}, diff --git a/man/add.sampling.Rd b/man/add.sampling.Rd index 28da6c7d2..05f352cd8 100644 --- a/man/add.sampling.Rd +++ b/man/add.sampling.Rd @@ -26,7 +26,7 @@ piping syntax through magrittr. It can also be accessed by } \examples{ -\donttest{ +\dontrun{ library(rxode2) library(units) @@ -58,16 +58,17 @@ mod1 <-function(){ ## These are making the more complex regimens of the rxode2 tutorial ## bid for 5 days -bid <- et(timeUnits="hr") \%>\% +bid <- et(timeUnits="hr") |> et(amt=10000,ii=12,until=set_units(5, "days")) ## qd for 5 days -qd <- et(timeUnits="hr") \%>\% +qd <- et(timeUnits="hr") |> et(amt=20000,ii=24,until=set_units(5, "days")) ## bid for 5 days followed by qd for 5 days -et <- seq(bid,qd) \%>\% et(seq(0,11*24,length.out=100)) +et <- seq(bid,qd) |> + et(seq(0,11*24,length.out=100)) bidQd <- rxSolve(mod1, et) @@ -77,11 +78,12 @@ plot(bidQd, C2) ## Now Infusion for 5 days followed by oral for 5 days ## note you can dose to a named compartment instead of using the compartment number -infusion <- et(timeUnits = "hr") \%>\% +infusion <- et(timeUnits = "hr") |> et(amt=10000, rate=5000, ii=24, until=set_units(5, "days"), cmt="centr") -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") et <- seq(infusion,qd) @@ -91,9 +93,10 @@ plot(infusionQd, C2) ## 2wk-on, 1wk-off -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- seq(qd, set_units(1,"weeks"), qd) \%>\% +et <- seq(qd, set_units(1,"weeks"), qd) |> add.sampling(set_units(seq(0, 5.5,by=0.005),weeks)) wkOnOff <- rxSolve(mod1, et) @@ -102,10 +105,11 @@ plot(wkOnOff, C2) ## You can also repeat the cycle easily with the rep function -qd <-et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <-et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- etRep(qd, times=4, wait=set_units(1,"weeks")) \%>\% - add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) +et <- etRep(qd, times=4, wait=set_units(1,"weeks")) |> + add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) repCycle4 <- rxSolve(mod1, et) @@ -116,8 +120,7 @@ plot(repCycle4, C2) \references{ Wang W, Hallow K, James D (2015). "A Tutorial on rxode2: Simulating Differential Equation Pharmacometric Models in R." CPT: -Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306, -. +Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306 } \seealso{ \code{\link{eventTable}}, \code{\link{add.sampling}}, diff --git a/man/assertCompartmentExists.Rd b/man/assertCompartmentExists.Rd index e7e1169ab..3784cf354 100644 --- a/man/assertCompartmentExists.Rd +++ b/man/assertCompartmentExists.Rd @@ -32,7 +32,9 @@ Other Assertions: \code{\link{assertCompartmentNew}()}, \code{\link{assertRxUi}()}, \code{\link{assertVariableExists}()}, -\code{\link{assertVariableNew}()} +\code{\link{assertVariableNew}()}, +\code{\link{testIniDf}()}, +\code{\link{testRxUnbounded}()} } \author{ Matthew Fidler & Bill Denney diff --git a/man/assertCompartmentName.Rd b/man/assertCompartmentName.Rd index 07f189c39..1ab647ffd 100644 --- a/man/assertCompartmentName.Rd +++ b/man/assertCompartmentName.Rd @@ -48,7 +48,9 @@ Other Assertions: \code{\link{assertCompartmentNew}()}, \code{\link{assertRxUi}()}, \code{\link{assertVariableExists}()}, -\code{\link{assertVariableNew}()} +\code{\link{assertVariableNew}()}, +\code{\link{testIniDf}()}, +\code{\link{testRxUnbounded}()} } \author{ Bill Denney diff --git a/man/assertCompartmentNew.Rd b/man/assertCompartmentNew.Rd index 4ef97fb3b..47ceb0281 100644 --- a/man/assertCompartmentNew.Rd +++ b/man/assertCompartmentNew.Rd @@ -23,7 +23,9 @@ Other Assertions: \code{\link{assertCompartmentName}()}, \code{\link{assertRxUi}()}, \code{\link{assertVariableExists}()}, -\code{\link{assertVariableNew}()} +\code{\link{assertVariableNew}()}, +\code{\link{testIniDf}()}, +\code{\link{testRxUnbounded}()} } \author{ Matthew Fidler & Bill Denney diff --git a/man/assertRxUi.Rd b/man/assertRxUi.Rd index e422d7efa..4dfdbdc86 100644 --- a/man/assertRxUi.Rd +++ b/man/assertRxUi.Rd @@ -102,7 +102,9 @@ Other Assertions: \code{\link{assertCompartmentName}()}, \code{\link{assertCompartmentNew}()}, \code{\link{assertVariableExists}()}, -\code{\link{assertVariableNew}()} +\code{\link{assertVariableNew}()}, +\code{\link{testIniDf}()}, +\code{\link{testRxUnbounded}()} } \author{ Matthew L. Fidler diff --git a/man/assertVariableExists.Rd b/man/assertVariableExists.Rd index f6a4c949b..7cad9157b 100644 --- a/man/assertVariableExists.Rd +++ b/man/assertVariableExists.Rd @@ -34,7 +34,9 @@ Other Assertions: \code{\link{assertCompartmentName}()}, \code{\link{assertCompartmentNew}()}, \code{\link{assertRxUi}()}, -\code{\link{assertVariableNew}()} +\code{\link{assertVariableNew}()}, +\code{\link{testIniDf}()}, +\code{\link{testRxUnbounded}()} } \author{ Matthew L. Fidler diff --git a/man/assertVariableNew.Rd b/man/assertVariableNew.Rd index 5167180de..d11298b97 100644 --- a/man/assertVariableNew.Rd +++ b/man/assertVariableNew.Rd @@ -23,7 +23,9 @@ Other Assertions: \code{\link{assertCompartmentName}()}, \code{\link{assertCompartmentNew}()}, \code{\link{assertRxUi}()}, -\code{\link{assertVariableExists}()} +\code{\link{assertVariableExists}()}, +\code{\link{testIniDf}()}, +\code{\link{testRxUnbounded}()} } \author{ Matthew L. Fidler diff --git a/man/boxCox.Rd b/man/boxCox.Rd new file mode 100644 index 000000000..c32634df3 --- /dev/null +++ b/man/boxCox.Rd @@ -0,0 +1,39 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/utils.R +\name{boxCox} +\alias{boxCox} +\alias{boxCoxInv} +\alias{yeoJohnson} +\alias{yeoJohnsonInv} +\title{boxCox/yeoJohnson and inverse boxCox/yeoJohnson functions} +\usage{ +boxCox(x, lambda = 1) + +boxCoxInv(x, lambda = 1) + +yeoJohnson(x, lambda = 1) + +yeoJohnsonInv(x, lambda = 1) +} +\arguments{ +\item{x}{input value(s) to transform} + +\item{lambda}{lambda value for the transformation} +} +\value{ +values from boxCox and boxCoxInv +} +\description{ +boxCox/yeoJohnson and inverse boxCox/yeoJohnson functions +} +\examples{ + +boxCox(10, 0.5) + +boxCoxInv(4.32, 0.5) + +yeoJohnson(10, 0.5) + +yeoJohnsonInv(4.32, 0.5) + +} diff --git a/man/dot-rxBlankIni.Rd b/man/dot-rxBlankIni.Rd new file mode 100644 index 000000000..d8ef5c522 --- /dev/null +++ b/man/dot-rxBlankIni.Rd @@ -0,0 +1,40 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/err.R +\name{.rxBlankIni} +\alias{.rxBlankIni} +\title{Get a blank, theta1, or eta1 initialization block for iniDf} +\usage{ +.rxBlankIni(type = c("empty", "theta", "eta")) +} +\arguments{ +\item{type}{type of initialization block to return} +} +\value{ +A data.frame with the appropriate number/type of columns. + +For type="empty", the data.frame will have 0 rows but all the correct types. + +For type="theta", the data.frame will have 1 row with the correct +types and default values. The "name" and "est" will likely need to +be updated. + +For type="eta", the data.frame will have 1 row with the correct +types and default values for the a single eta being added. The +"name" and "est" will likely need to be updated. +} +\description{ +Get a blank, theta1, or eta1 initialization block for iniDf +} +\examples{ + +.rxBlankIni("empty") + +.rxBlankIni("theta") + +.rxBlankIni("eta") + +} +\author{ +Matthew L. Fidler +} +\keyword{internal} diff --git a/man/dot-rxPrune.Rd b/man/dot-rxPrune.Rd index 432b6dd4f..75d19e1f2 100644 --- a/man/dot-rxPrune.Rd +++ b/man/dot-rxPrune.Rd @@ -4,12 +4,14 @@ \alias{.rxPrune} \title{Internal Pruning function} \usage{ -.rxPrune(x, envir = parent.frame()) +.rxPrune(x, envir = parent.frame(), strAssign = list()) } \arguments{ \item{x}{List of quoted lines} \item{envir}{Environment where information is stored} + +\item{strAssign}{string assignment list from model variables} } \value{ Pruned model code diff --git a/man/dot-rxTransform.Rd b/man/dot-rxTransform.Rd new file mode 100644 index 000000000..6dd0db20b --- /dev/null +++ b/man/dot-rxTransform.Rd @@ -0,0 +1,52 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/utils.R +\name{.rxTransform} +\alias{.rxTransform} +\title{rxode2 general transformation function} +\usage{ +.rxTransform( + x, + lambda = 1, + low = 0, + high = 1, + transform = c("boxCox", "yeoJohnson", "untransformed", "lnorm", "logit", + "logit + yeoJohnson", "probit", "probit + yeoJohnson", "logit + boxCox", + "probit + boxCox"), + inverse = FALSE +) +} +\arguments{ +\item{x}{value that will be transformed} + +\item{lambda}{lambda value for the transformation} + +\item{low}{lower bound for the transformation} + +\item{high}{upper bound for the transformation} + +\item{transform}{transformation to use (can be integer or string +matching supported transformations)} + +\item{inverse}{boolean if the inverse transformation should be performed} +} +\value{ +transformed value +} +\description{ +rxode2 general transformation function +} +\examples{ + +logit(0.25) + +.rxTransform(0.25, transform="logit") + +expit(-1.09) + +.rxTransform(-1.09, transform="logit", inverse=TRUE) + +} +\author{ +Matthew L. Fidler +} +\keyword{internal} diff --git a/man/dot-rxode2ptrs.Rd b/man/dot-rxode2ptrs.Rd new file mode 100644 index 000000000..abd0222c3 --- /dev/null +++ b/man/dot-rxode2ptrs.Rd @@ -0,0 +1,22 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rxode-options.R +\name{.rxode2ptrs} +\alias{.rxode2ptrs} +\title{Get the rxode2 function pointers} +\usage{ +.rxode2ptrs() +} +\value{ +a list of function pointers +} +\description{ +This function is used to get the function pointers for rxode2. This is +used to allow rxode2 to have binary linkage to nlmixr2est. +} +\examples{ + +.rxode2ptrs() +} +\author{ +Matthew L. Fidler +} diff --git a/man/et.Rd b/man/et.Rd index edb7b5e54..558324ac1 100644 --- a/man/et.Rd +++ b/man/et.Rd @@ -163,7 +163,7 @@ Event Table Function } \examples{ -\donttest{ +\dontrun{ library(rxode2) library(units) @@ -195,16 +195,17 @@ mod1 <-function(){ ## These are making the more complex regimens of the rxode2 tutorial ## bid for 5 days -bid <- et(timeUnits="hr") \%>\% +bid <- et(timeUnits="hr") |> et(amt=10000,ii=12,until=set_units(5, "days")) ## qd for 5 days -qd <- et(timeUnits="hr") \%>\% +qd <- et(timeUnits="hr") |> et(amt=20000,ii=24,until=set_units(5, "days")) ## bid for 5 days followed by qd for 5 days -et <- seq(bid,qd) \%>\% et(seq(0,11*24,length.out=100)) +et <- seq(bid,qd) |> + et(seq(0,11*24,length.out=100)) bidQd <- rxSolve(mod1, et) @@ -214,11 +215,12 @@ plot(bidQd, C2) ## Now Infusion for 5 days followed by oral for 5 days ## note you can dose to a named compartment instead of using the compartment number -infusion <- et(timeUnits = "hr") \%>\% +infusion <- et(timeUnits = "hr") |> et(amt=10000, rate=5000, ii=24, until=set_units(5, "days"), cmt="centr") -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") et <- seq(infusion,qd) @@ -228,9 +230,10 @@ plot(infusionQd, C2) ## 2wk-on, 1wk-off -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- seq(qd, set_units(1,"weeks"), qd) \%>\% +et <- seq(qd, set_units(1,"weeks"), qd) |> add.sampling(set_units(seq(0, 5.5,by=0.005),weeks)) wkOnOff <- rxSolve(mod1, et) @@ -239,10 +242,11 @@ plot(wkOnOff, C2) ## You can also repeat the cycle easily with the rep function -qd <-et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <-et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- etRep(qd, times=4, wait=set_units(1,"weeks")) \%>\% - add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) +et <- etRep(qd, times=4, wait=set_units(1,"weeks")) |> + add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) repCycle4 <- rxSolve(mod1, et) @@ -253,8 +257,7 @@ plot(repCycle4, C2) \references{ Wang W, Hallow K, James D (2015). "A Tutorial on rxode2: Simulating Differential Equation Pharmacometric Models in R." CPT: -Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306, -. +Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306 } \seealso{ \code{\link{eventTable}}, \code{\link{add.sampling}}, diff --git a/man/etRbind.Rd b/man/etRbind.Rd index 8c2ffdfb2..7b6389103 100644 --- a/man/etRbind.Rd +++ b/man/etRbind.Rd @@ -59,7 +59,7 @@ Combining event tables } \examples{ -\donttest{ +\dontrun{ library(rxode2) library(units) @@ -91,16 +91,17 @@ mod1 <-function(){ ## These are making the more complex regimens of the rxode2 tutorial ## bid for 5 days -bid <- et(timeUnits="hr") \%>\% +bid <- et(timeUnits="hr") |> et(amt=10000,ii=12,until=set_units(5, "days")) ## qd for 5 days -qd <- et(timeUnits="hr") \%>\% +qd <- et(timeUnits="hr") |> et(amt=20000,ii=24,until=set_units(5, "days")) ## bid for 5 days followed by qd for 5 days -et <- seq(bid,qd) \%>\% et(seq(0,11*24,length.out=100)) +et <- seq(bid,qd) |> + et(seq(0,11*24,length.out=100)) bidQd <- rxSolve(mod1, et) @@ -110,11 +111,12 @@ plot(bidQd, C2) ## Now Infusion for 5 days followed by oral for 5 days ## note you can dose to a named compartment instead of using the compartment number -infusion <- et(timeUnits = "hr") \%>\% +infusion <- et(timeUnits = "hr") |> et(amt=10000, rate=5000, ii=24, until=set_units(5, "days"), cmt="centr") -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") et <- seq(infusion,qd) @@ -124,9 +126,10 @@ plot(infusionQd, C2) ## 2wk-on, 1wk-off -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- seq(qd, set_units(1,"weeks"), qd) \%>\% +et <- seq(qd, set_units(1,"weeks"), qd) |> add.sampling(set_units(seq(0, 5.5,by=0.005),weeks)) wkOnOff <- rxSolve(mod1, et) @@ -135,10 +138,11 @@ plot(wkOnOff, C2) ## You can also repeat the cycle easily with the rep function -qd <-et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <-et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- etRep(qd, times=4, wait=set_units(1,"weeks")) \%>\% - add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) +et <- etRep(qd, times=4, wait=set_units(1,"weeks")) |> + add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) repCycle4 <- rxSolve(mod1, et) @@ -149,8 +153,7 @@ plot(repCycle4, C2) \references{ Wang W, Hallow K, James D (2015). "A Tutorial on rxode2: Simulating Differential Equation Pharmacometric Models in R." CPT: -Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306, -. +Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306 } \seealso{ \code{\link{eventTable}}, \code{\link{add.sampling}}, diff --git a/man/etRep.Rd b/man/etRep.Rd index 4aaedecd2..a850e88e0 100644 --- a/man/etRep.Rd +++ b/man/etRep.Rd @@ -77,7 +77,7 @@ Repeat an rxode2 event table } \examples{ -\donttest{ +\dontrun{ library(rxode2) library(units) @@ -109,16 +109,17 @@ mod1 <-function(){ ## These are making the more complex regimens of the rxode2 tutorial ## bid for 5 days -bid <- et(timeUnits="hr") \%>\% +bid <- et(timeUnits="hr") |> et(amt=10000,ii=12,until=set_units(5, "days")) ## qd for 5 days -qd <- et(timeUnits="hr") \%>\% +qd <- et(timeUnits="hr") |> et(amt=20000,ii=24,until=set_units(5, "days")) ## bid for 5 days followed by qd for 5 days -et <- seq(bid,qd) \%>\% et(seq(0,11*24,length.out=100)) +et <- seq(bid,qd) |> + et(seq(0,11*24,length.out=100)) bidQd <- rxSolve(mod1, et) @@ -128,11 +129,12 @@ plot(bidQd, C2) ## Now Infusion for 5 days followed by oral for 5 days ## note you can dose to a named compartment instead of using the compartment number -infusion <- et(timeUnits = "hr") \%>\% +infusion <- et(timeUnits = "hr") |> et(amt=10000, rate=5000, ii=24, until=set_units(5, "days"), cmt="centr") -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") et <- seq(infusion,qd) @@ -142,9 +144,10 @@ plot(infusionQd, C2) ## 2wk-on, 1wk-off -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- seq(qd, set_units(1,"weeks"), qd) \%>\% +et <- seq(qd, set_units(1,"weeks"), qd) |> add.sampling(set_units(seq(0, 5.5,by=0.005),weeks)) wkOnOff <- rxSolve(mod1, et) @@ -153,10 +156,11 @@ plot(wkOnOff, C2) ## You can also repeat the cycle easily with the rep function -qd <-et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <-et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- etRep(qd, times=4, wait=set_units(1,"weeks")) \%>\% - add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) +et <- etRep(qd, times=4, wait=set_units(1,"weeks")) |> + add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) repCycle4 <- rxSolve(mod1, et) @@ -167,8 +171,7 @@ plot(repCycle4, C2) \references{ Wang W, Hallow K, James D (2015). "A Tutorial on rxode2: Simulating Differential Equation Pharmacometric Models in R." CPT: -Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306, -. +Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306 } \seealso{ \code{\link{eventTable}}, \code{\link{add.sampling}}, diff --git a/man/etSeq.Rd b/man/etSeq.Rd index 3332820ac..d92dc9b28 100644 --- a/man/etSeq.Rd +++ b/man/etSeq.Rd @@ -56,7 +56,7 @@ interval. } \examples{ -\donttest{ +\dontrun{ library(rxode2) library(units) @@ -88,16 +88,17 @@ mod1 <-function(){ ## These are making the more complex regimens of the rxode2 tutorial ## bid for 5 days -bid <- et(timeUnits="hr") \%>\% +bid <- et(timeUnits="hr") |> et(amt=10000,ii=12,until=set_units(5, "days")) ## qd for 5 days -qd <- et(timeUnits="hr") \%>\% +qd <- et(timeUnits="hr") |> et(amt=20000,ii=24,until=set_units(5, "days")) ## bid for 5 days followed by qd for 5 days -et <- seq(bid,qd) \%>\% et(seq(0,11*24,length.out=100)) +et <- seq(bid,qd) |> + et(seq(0,11*24,length.out=100)) bidQd <- rxSolve(mod1, et) @@ -107,11 +108,12 @@ plot(bidQd, C2) ## Now Infusion for 5 days followed by oral for 5 days ## note you can dose to a named compartment instead of using the compartment number -infusion <- et(timeUnits = "hr") \%>\% +infusion <- et(timeUnits = "hr") |> et(amt=10000, rate=5000, ii=24, until=set_units(5, "days"), cmt="centr") -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(5, "days"), cmt="depot") et <- seq(infusion,qd) @@ -121,9 +123,10 @@ plot(infusionQd, C2) ## 2wk-on, 1wk-off -qd <- et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <- et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- seq(qd, set_units(1,"weeks"), qd) \%>\% +et <- seq(qd, set_units(1,"weeks"), qd) |> add.sampling(set_units(seq(0, 5.5,by=0.005),weeks)) wkOnOff <- rxSolve(mod1, et) @@ -132,10 +135,11 @@ plot(wkOnOff, C2) ## You can also repeat the cycle easily with the rep function -qd <-et(timeUnits = "hr") \%>\% et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") +qd <-et(timeUnits = "hr") |> + et(amt=10000, ii=24, until=set_units(2, "weeks"), cmt="depot") -et <- etRep(qd, times=4, wait=set_units(1,"weeks")) \%>\% - add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) +et <- etRep(qd, times=4, wait=set_units(1,"weeks")) |> + add.sampling(set_units(seq(0, 12.5,by=0.005),weeks)) repCycle4 <- rxSolve(mod1, et) @@ -146,8 +150,7 @@ plot(repCycle4, C2) \references{ Wang W, Hallow K, James D (2015). "A Tutorial on rxode2: Simulating Differential Equation Pharmacometric Models in R." CPT: -Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306, -. +Pharmacometrics and Systems Pharmacology, 5(1), 3-10. ISSN 2163-8306 } \seealso{ \code{\link{eventTable}}, \code{\link{add.sampling}}, diff --git a/man/forderForceBase.Rd b/man/forderForceBase.Rd index af21425e9..52490c7be 100644 --- a/man/forderForceBase.Rd +++ b/man/forderForceBase.Rd @@ -1,5 +1,5 @@ % Generated by roxygen2: do not edit by hand -% Please edit documentation in R/RcppExports.R +% Please edit documentation in R/forder.R \name{forderForceBase} \alias{forderForceBase} \title{Force using base order for rxode2 radix sorting} @@ -12,7 +12,8 @@ forderForceBase(forceBase = FALSE) \code{data.table}'s parallel radix sorting.} } \value{ -NILL; called for side effects +value of \code{forceBase} (can change if \code{data.table} is not +available) } \description{ Force using base order for rxode2 radix sorting diff --git a/man/ini.Rd b/man/ini.Rd index caf686237..e8dde878b 100644 --- a/man/ini.Rd +++ b/man/ini.Rd @@ -63,14 +63,17 @@ warning. 'omega' values can be set as a single value or as the values of a lower-triangular matrix. The values may be set as either a -variance-covariance matrix (the default) or as a correlation matrix for the -off-diagonals with the standard deviations on the diagonals. Names may be -set on the left side of the \code{~}. To set a variance-covariance matrix -with variance values of 2 and 3 and a covariance of -2.5 use \code{~c(2, 2.5, -3)}. To set the same matrix with names of \code{iivKa} and \code{iivCL}, use -\code{iivKa + iivCL~c(2, 2.5, 3)}. To set a correlation matrix with standard -deviations on the diagonal, use \code{cor()} like \code{iivKa + iivCL~cor(2, --0.5, 3)}. +variance-covariance matrix (the default) or as a correlation matrix +for the off-diagonals with the standard deviations on the +diagonals. Names may be set on the left side of the \code{~}. To +set a variance-covariance matrix with variance values of 2 and 3 +and a covariance of -2.5 use \code{~c(2, 2.5, 3)}. To set the same +matrix with names of \code{iivKa} and \code{iivCL}, use \code{iivKa ++ iivCL~c(2, 2.5, 3)}. To set a correlation matrix with standard +deviations on the diagonal, use \code{cor()} like \code{iivKa + +iivCL~cor(2, -0.5, 3)}. As of rxode2 3.0 you can also use +\code{iivKa ~ 2, iivCL ~ c(2.5, 3)} for covariance matrices as +well. Values may be fixed (and therefore not estimated) using either the name \code{fixed} at the end of the assignment or by calling \code{fixed()} as a @@ -99,6 +102,13 @@ estimation. The typical way to set a label so that the parameter \code{tvCL} has a label of "Typical Value of Clearance (L/hr)" is \code{tvCL <- 1; label("Typical Value of Clearance (L/hr)")}. +Off diagonal values of 'omega' can be set to zero using the +\code{diag()} to remove all off-diagonals can be removed with +\code{ini(diag())}. To remove covariances of 'omega' item with \code{iivKa}, +you can use \verb{\%>\% ini(diag(iivKa))}. Or to remove covariances that +contain either \code{iivKa} or \code{iivCl} you can use \verb{\%>\% ini(diag(iivKa, iivCl))}. For finer control you can remove the covariance between +two items (like \code{iivKa} and \code{iivCl}) by `\%>\% ini(-cov(iivKa, iivCl)) + \code{rxode2}/\code{nlmixr2} will attempt to determine some back-transformations for the user. For example, \code{CL <- exp(tvCL)} will detect that \code{tvCL} must be back-transformed by \code{exp()} for easier diff --git a/man/linMod.Rd b/man/linMod.Rd new file mode 100644 index 000000000..1b72580dd --- /dev/null +++ b/man/linMod.Rd @@ -0,0 +1,117 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/linMod.R +\name{linMod} +\alias{linMod} +\alias{linMod0} +\alias{linModB} +\alias{linModB0} +\alias{linModA} +\alias{linModA0} +\alias{linModD} +\alias{linModD0} +\alias{linModM} +\alias{linModM0} +\title{Linear model to replace in rxode2 ui model} +\usage{ +linMod( + variable, + power, + dv = "dv", + intercept = TRUE, + type = c("replace", "before", "after"), + num = NULL, + iniDf = NULL, + data = FALSE, + mv = FALSE +) + +linMod0(..., intercept = FALSE) + +linModB(..., type = "before") + +linModB0(..., intercept = FALSE, type = "before") + +linModA(..., type = "after") + +linModA0(..., intercept = FALSE, type = "after") + +linModD(..., intercept = TRUE, data = TRUE) + +linModD0(..., intercept = FALSE, data = TRUE) + +linModM(..., intercept = TRUE, mv = TRUE) + +linModM0(..., intercept = FALSE, mv = TRUE) +} +\arguments{ +\item{variable}{The variable that the rxode2 will be made on.} + +\item{power}{The power of the polynomial that will be generated.} + +\item{dv}{the dependent variable to use to generate the initial +estimates from the data. If \code{NULL} query using \code{rxUdfUiData()}.} + +\item{intercept}{Boolean that tells if the intercept be generated.} + +\item{type}{the type of linear model replacement to be used.} + +\item{num}{the number the particular model is being generated. If +unspecified, query using \code{rxUdfUiNum()}.} + +\item{iniDf}{the initialization \code{data.frame}, if \code{NULL} query using +\code{rxUdfUiIniDf()}} + +\item{data}{logical that tells if the initial estimates of the +linear model should be estimated from the data.} + +\item{mv}{logical that tell if the model variables need to be used +to generate model variables.} + +\item{...}{arguments that are passed to \code{linMod()} for the other +abbreviations of \code{linMod()}} +} +\value{ +a list for use in when generating the \code{rxode2} ui model see +\code{rxUdfUi()} for details. +} +\description{ +Linear model to replace in rxode2 ui model +} +\section{Functions}{ +\itemize{ +\item \code{linMod0()}: linear model without intercept + +\item \code{linModB()}: linear model before where it occurs + +\item \code{linModB0()}: linear model before where the user function occurs + +\item \code{linModA()}: linear model after where the user function occurs + +\item \code{linModA0()}: liner model without an intercept placed after where the user function occurs + +\item \code{linModD()}: linear model where initial estimates are generated from the data + +\item \code{linModD0()}: linear model where initial estimates are generated from the data (no intercept) + +\item \code{linModM()}: linear model where the model variables are used to generate the model variables + +\item \code{linModM0()}: linear model where the model variables are used to generate the model variables (no intercept) + +}} +\examples{ + +linMod(x, 3) +} +\seealso{ +Other User functions: +\code{\link{rxUdfUiData}()}, +\code{\link{rxUdfUiEst}()}, +\code{\link{rxUdfUiIniLhs}()}, +\code{\link{rxUdfUiMv}()}, +\code{\link{rxUdfUiNum}()}, +\code{\link{rxUdfUiParsing}()} +} +\author{ +Matthew L. Fidler +} +\concept{User functions} diff --git a/man/logit.Rd b/man/logit.Rd index 580f392cf..a90eb22ad 100644 --- a/man/logit.Rd +++ b/man/logit.Rd @@ -65,4 +65,5 @@ expit(-1.09) logitNormInfo(logit(0.25), sd = 0.1) logitNormInfo(logit(1, 0, 10), sd = 1, low = 0, high = 10) + } diff --git a/man/rmdhunks/rxode2-create-models.Rmd b/man/rmdhunks/rxode2-create-models.Rmd index d71ccf870..17e6c3fdf 100644 --- a/man/rmdhunks/rxode2-create-models.Rmd +++ b/man/rmdhunks/rxode2-create-models.Rmd @@ -1,8 +1,8 @@ -The ODE-based model specification may be coded inside four places: +The ODE-based model specification may be coded inside four places: - Inside a `rxode2({})` block statements: -```{r modBracket} +``` r library(rxode2) mod <- rxode2({ # simple assignment @@ -15,7 +15,7 @@ mod <- rxode2({ - Inside a `rxode2("")` string statement: -```{r modString} +``` r mod <- rxode2(" # simple assignment C2 <- centr/V2 @@ -27,7 +27,7 @@ mod <- rxode2(" - In a file name to be loaded by rxode2: -```{r modFile} +``` r writeLines(" # simple assignment C2 <- centr/V2 @@ -38,10 +38,10 @@ writeLines(" mod <- rxode2(filename='modelFile.rxode2') unlink("modelFile.rxode2") ``` - + - In a model function which can be parsed by `rxode2`: -```{r modFun} +``` r mod <- function() { model({ # simple assignment @@ -94,10 +94,10 @@ For the last type of model (a model function), a call to `rxode2` creates a parsed `rxode2` ui that can be translated to the `rxode2` compilation model. -```{r} +``` r mod$simulationModel -# or +# or mod$simulationIniModel ``` diff --git a/man/rmdhunks/rxode2-syntax-hunk.Rmd b/man/rmdhunks/rxode2-syntax-hunk.Rmd index 1c2b1a08b..128743aeb 100644 --- a/man/rmdhunks/rxode2-syntax-hunk.Rmd +++ b/man/rmdhunks/rxode2-syntax-hunk.Rmd @@ -1,6 +1,6 @@ --- -editor_options: - markdown: +editor_options: + markdown: wrap: 72 --- @@ -18,7 +18,7 @@ printing statements (for debugging/testing). Assignment statements can be: - **simple** assignments, where the left hand is an identifier (i.e., - variable) + variable). This includes string assignments - special **time-derivative** assignments, where the left hand specifies the change of the amount in the corresponding state @@ -33,8 +33,7 @@ Assignment statements can be: (`rate(depot)=2`) and **modeled duration** (`dur(depot)=2`). An example of these model features and the event specification for the modeled infusions the rxode2 data specification is found in [rxode2 - events - vignette](https://nlmixr2.github.io/rxode2/articles/rxode2-event-types.html). + events vignette](https://nlmixr2.github.io/rxode2/articles/rxode2-event-types.html). - special **change point syntax, or model times**. These model times are specified by `mtime(var)=time` @@ -47,6 +46,12 @@ Assignment statements can be: for very stiff ODE systems. However, for the few stiff systems we tried with LSODA, this actually slightly slowed down the solving. +- Special **string value declarations** which tell what values a + string variable will take within a `rxode2` solving structure. + These values will then cause a factor to be created for this + variable on solving the `rxode2` model. As such, they are declared + in much the same way as `R`, that is: `labels(a) <- c("a1", "a2")`. + Note that assignment can be done by `=`, `<-` or `~`. When assigning with the `~` operator, the **simple assignments** and @@ -67,9 +72,16 @@ Special statements can be: parameter order the same when using 2 different ODE models. These are specified by `param(par1, par2,...)` +- **Variable interpolation statements**, which tells the + interpolation for specific covariates. These include `locf(cov1, + cov2, ...)` for last observation carried forward, `nocb(cov1, + cov2, ...)` for next observation carried backward, `linear(cov1, + cov2, ...)` for linear interpolation and `midpoint(cov1, cov2, + ...)` for midpoint interpolation. + An example model is shown below: -``` +``` # simple assignment C2 <- centr/V2 @@ -125,7 +137,12 @@ assigned, or used as a state but can be accessed in the rxode2 code: - `dvid` - `addl` - `ss` +- `amt` +- `dur` - `rate` +- `Rprintf` +- `print` +- `printf` - `id` However the following variables are cannot be used in a model @@ -147,7 +164,7 @@ Logical operators support the standard R operators `==`, `!=` `>=` `<=` `ifelse()` expressions. Additionally they can be in a standard assignment. For instance, the following is valid: -``` +``` cov1 = covm*(sexf == "female") + covm*(sexf != "female") ``` @@ -356,3 +373,62 @@ In general all the that are supported are in the following table ```{r rxResidualError, echo=FALSE, screenshot.force=FALSE} .rxDocTable(rxResidualError, "rxode2/nlmixr2 esidual error specification") ``` + +# Note on strings in rxode2 + +Strings are converted to double values inside of `rxode2`, hence you +can refer to them as an integer corresponding to the string value or +the string value itself. For covariates these are calculated on the +fly based on your data and you should likely not try this, though you +should be aware. For strings defined in the model, this is fixed and +both could be used. + +For example: +``` +if (APGAR == 10 || APGAR == 8 || APGAR == 9) { + tAPGAR <- "High" + } else if (APGAR == 1 || APGAR == 2 || APGAR == 3) { + tAPGAR <- "Low" + } else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) { + tAPGAR <- "Med" + } else { + tAPGAR<- "Med" + } +``` + +Could also be replaced by: + +``` +if (APGAR == 10 || APGAR == 8 || APGAR == 9) { + tAPGAR <- "High" + } else if (APGAR == 1 || APGAR == 2 || APGAR == 3) { + tAPGAR <- "Low" + } else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) { + tAPGAR <- "Med" + } else { + tAPGAR<- 3 + } +``` + +Since `"Med"` is already defined + +If you wanted you can pre-declare what levels it has (and the order) +to give you better control of this: + +``` +levels(tAPGAR) <- c("Med", "Low", "High") +if (APGAR == 10 || APGAR == 8 || APGAR == 9) { + tAPGAR <- 3 + } else if (APGAR == 1 || APGAR == 2 || APGAR == 3) { + tAPGAR <- 2 + } else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) { + tAPGAR <- 1 + } else { + tAPGAR<- 1 + } +``` + +You can see that the number changed since the declaration change the +numbers in each variable for `tAPGAR`. These `levels()` statements +need to be declared before the variable occurs to ensure the numbering +is consistent with what is declared. diff --git a/man/rxCombineErrorLines.Rd b/man/rxCombineErrorLines.Rd index 2c81fa047..7b78fa72e 100644 --- a/man/rxCombineErrorLines.Rd +++ b/man/rxCombineErrorLines.Rd @@ -13,7 +13,9 @@ rxCombineErrorLines( cmtLines = TRUE, dvidLine = TRUE, lstExpr = NULL, - useIf = TRUE + useIf = TRUE, + interpLines = NULL, + levelLines = NULL ) } \arguments{ @@ -37,6 +39,11 @@ defaults to the model expressions accessible by \code{uiModel$lstExpr}.} \item{useIf}{Use an \verb{if (CMT == X)} for endpoints} + +\item{interpLines}{Interpolation lines, if not present} + +\item{levelLines}{Levels lines for assigned strings. If not +present, use the interpolation lines from the current model.} } \value{ quoted expression that can be evaluated to compiled rxode2 diff --git a/man/rxEvid.Rd b/man/rxEvid.Rd index cbacbf7a3..70e769f1d 100644 --- a/man/rxEvid.Rd +++ b/man/rxEvid.Rd @@ -7,6 +7,7 @@ \alias{[.rxEvid} \alias{as.character.rxEvid} \alias{[[.rxEvid} +\alias{units<-.rxEvid} \alias{c.rxRateDur} \alias{format.rxEvid} \alias{format.rxRateDur} @@ -25,6 +26,8 @@ as.rxEvid(x) \method{[[}{rxEvid}(x, ...) +\method{units}{rxEvid}(x) <- value + \method{c}{rxRateDur}(x, ...) \method{format}{rxEvid}(x, ...) @@ -37,6 +40,8 @@ as.rxEvid(x) \item{x}{Item to be converted to a rxode2 EVID specification.} \item{...}{Other parameters} + +\item{value}{It will be an error to set units for evid} } \value{ rxEvid specification diff --git a/man/rxIntToBase.Rd b/man/rxIntToBase.Rd new file mode 100644 index 000000000..08a559360 --- /dev/null +++ b/man/rxIntToBase.Rd @@ -0,0 +1,27 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxIntToBase} +\alias{rxIntToBase} +\title{Convert a positive base} +\usage{ +rxIntToBase(x, base = 36L) +} +\arguments{ +\item{x}{integer to convert} + +\item{base}{can be 2 to 36} +} +\value{ +a sequence of letters and representing the number(s) input +} +\description{ +Convert a positive base +} +\examples{ + +rxIntToBase(1:100) + +} +\author{ +Matthew L. Fidler +} diff --git a/man/rxIntToLetter.Rd b/man/rxIntToLetter.Rd new file mode 100644 index 000000000..3f833fa7f --- /dev/null +++ b/man/rxIntToLetter.Rd @@ -0,0 +1,27 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxIntToLetter} +\alias{rxIntToLetter} +\title{Convert a positive integer to a letter series} +\usage{ +rxIntToLetter(x, base = 26L) +} +\arguments{ +\item{x}{integer to convert} + +\item{base}{can be 2 to 26} +} +\value{ +a sequence of letters representing the number(s) input +} +\description{ +Convert a positive integer to a letter series +} +\examples{ + +rxIntToLetter(1:100) + +} +\author{ +Matthew L. Fidler +} diff --git a/man/rxSolve.Rd b/man/rxSolve.Rd index 0c547468d..1d04267e5 100644 --- a/man/rxSolve.Rd +++ b/man/rxSolve.Rd @@ -48,6 +48,7 @@ rxSolve( cores, covsInterpolation = c("locf", "linear", "nocb", "midpoint"), naInterpolation = c("locf", "nocb"), + keepInterpolation = c("na", "locf", "nocb"), addCov = TRUE, sigma = NULL, sigmaDf = NULL, @@ -113,6 +114,8 @@ rxSolve( ssAtol = 1e-08, ssRtol = 1e-06, safeZero = TRUE, + safeLog = TRUE, + safePow = TRUE, sumType = c("pairwise", "fsum", "kahan", "neumaier", "c"), prodType = c("long double", "double", "logify"), sensType = c("advan", "autodiff", "forward", "central"), @@ -377,6 +380,17 @@ missing. If all the covariates are missing and you find the end/beginning of the individual record, switch direction. If all are really missing, then return missing.} +\item{keepInterpolation}{specifies the interpolation method for +variables in the \code{keep} column. When \code{nlmixr2} creates \code{mtime}, +\code{addl} doses etc, these items were not originally in the dataset. +The interpolation methods you can choose are: +\itemize{ +\item \code{"locf"} -- last observation carried forward (default) +\item \code{"nocb"} -- next observation carried backward. +\item \code{"na"} -- no interpolation, simply put \code{NA} for the +interpolated \code{keep} covariates. +}} + \item{addCov}{A boolean indicating if covariates should be added to the output matrix or data frame. By default this is disabled.} @@ -723,9 +737,14 @@ a vector based on each state.} \item{ssRtol}{Steady state rtol convergence factor. Can be a vector based on each state.} -\item{safeZero}{Use safe zero divide and log routines. By default +\item{safeZero}{Use safe zero divide. By default this is turned on but you may turn it off if you wish.} +\item{safeLog}{Use safe log. When enabled if your value that you are taking log() of is negative or zero, this will return \verb{log(machine epsilon)}. By default this is turned on.} + +\item{safePow}{Use safe powers. When enabled if your power is +negative and your base is zero, this will return the \verb{machine epsilon^(negative power)}. By default this is turned on.} + \item{sumType}{Sum type to use for \code{sum()} in rxode2 code blocks. diff --git a/man/rxUdfUi.Rd b/man/rxUdfUi.Rd new file mode 100644 index 000000000..7a386c629 --- /dev/null +++ b/man/rxUdfUi.Rd @@ -0,0 +1,30 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUi} +\alias{rxUdfUi} +\title{This function is called when processing rxode2 user functions from +the models} +\usage{ +rxUdfUi(fun) +} +\arguments{ +\item{fun}{this is the function that needs to be parsed and +changed. This is a R language expression} +} +\value{ +This needs to return a list with the following elements: +\itemize{ +\item \code{iniDf} -- the modified initial estimate data.frame +\item \code{before} -- any model code that needs to be added before the current line +\item \code{after} -- any model code that needs to be added after the current line +\item \code{replace} -- replacement code for this user function +} +} +\description{ +This function is called when processing rxode2 user functions from +the models +} +\author{ +Matthew L. Fidler +} +\keyword{internal} diff --git a/man/rxUdfUiData.Rd b/man/rxUdfUiData.Rd new file mode 100644 index 000000000..284d5369f --- /dev/null +++ b/man/rxUdfUiData.Rd @@ -0,0 +1,35 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiData} +\alias{rxUdfUiData} +\title{Return the data.frame that is being processed or setup data.frame for processing} +\usage{ +rxUdfUiData(value) +} +\arguments{ +\item{value}{when specified, this assigns the data.frame to be processed, or resets it by assigning it to be \code{NULL}.} +} +\value{ +value of the \code{data.frame} being processed or \code{NULL}. +} +\description{ +Return the data.frame that is being processed or setup data.frame for processing +} +\examples{ + +rxUdfUiData() + +} +\seealso{ +Other User functions: +\code{\link{linMod}()}, +\code{\link{rxUdfUiEst}()}, +\code{\link{rxUdfUiIniLhs}()}, +\code{\link{rxUdfUiMv}()}, +\code{\link{rxUdfUiNum}()}, +\code{\link{rxUdfUiParsing}()} +} +\author{ +Matthew L. Fidler +} +\concept{User functions} diff --git a/man/rxUdfUiEst.Rd b/man/rxUdfUiEst.Rd new file mode 100644 index 000000000..fbcde6a43 --- /dev/null +++ b/man/rxUdfUiEst.Rd @@ -0,0 +1,36 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiEst} +\alias{rxUdfUiEst} +\title{Return the current estimation method for the UI processing} +\usage{ +rxUdfUiEst(value) +} +\arguments{ +\item{value}{when specified, this assigns the character value of +the estimation method or NULL if there is nothing being estimated} +} +\value{ +value of the estimation method being processed or NULL +} +\description{ +Return the current estimation method for the UI processing +} +\examples{ + +rxUdfUiEst() + +} +\seealso{ +Other User functions: +\code{\link{linMod}()}, +\code{\link{rxUdfUiData}()}, +\code{\link{rxUdfUiIniLhs}()}, +\code{\link{rxUdfUiMv}()}, +\code{\link{rxUdfUiNum}()}, +\code{\link{rxUdfUiParsing}()} +} +\author{ +Matthew L. Fidler +} +\concept{User functions} diff --git a/man/rxUdfUiIniDf.Rd b/man/rxUdfUiIniDf.Rd new file mode 100644 index 000000000..1fe07d7c2 --- /dev/null +++ b/man/rxUdfUiIniDf.Rd @@ -0,0 +1,22 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiIniDf} +\alias{rxUdfUiIniDf} +\title{Get the rxode2 iniDf of the current UI being processed (or return NULL)} +\usage{ +rxUdfUiIniDf() +} +\value{ +Initial \code{data.frame} being processed or \code{NULL} for nothing. +} +\description{ +Get the rxode2 iniDf of the current UI being processed (or return NULL) +} +\examples{ + +rxUdfUiIniDf() + +} +\author{ +Matthew L. Fidler +} diff --git a/man/rxUdfUiIniLhs.Rd b/man/rxUdfUiIniLhs.Rd new file mode 100644 index 000000000..1b65b69f5 --- /dev/null +++ b/man/rxUdfUiIniLhs.Rd @@ -0,0 +1,32 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiIniLhs} +\alias{rxUdfUiIniLhs} +\title{Return the lhs parsed language expression} +\usage{ +rxUdfUiIniLhs() +} +\value{ +lhs language expression or NULL +} +\description{ +Return the lhs parsed language expression +} +\examples{ + +rxUdfUiIniLhs() + +} +\seealso{ +Other User functions: +\code{\link{linMod}()}, +\code{\link{rxUdfUiData}()}, +\code{\link{rxUdfUiEst}()}, +\code{\link{rxUdfUiMv}()}, +\code{\link{rxUdfUiNum}()}, +\code{\link{rxUdfUiParsing}()} +} +\author{ +Matthew L. Fidler +} +\concept{User functions} diff --git a/man/rxUdfUiMv.Rd b/man/rxUdfUiMv.Rd new file mode 100644 index 000000000..588f79148 --- /dev/null +++ b/man/rxUdfUiMv.Rd @@ -0,0 +1,38 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiMv} +\alias{rxUdfUiMv} +\title{Return the model variables that is being processed or setup model +variables for processing} +\usage{ +rxUdfUiMv(value) +} +\arguments{ +\item{value}{when specified, this assigns the model variables to be +processed, or resets it by assigning it to be \code{NULL}.} +} +\value{ +value of the \code{modelVariables} being processed or \code{NULL}. +} +\description{ +Return the model variables that is being processed or setup model +variables for processing +} +\examples{ + +rxUdfUiMv() + +} +\seealso{ +Other User functions: +\code{\link{linMod}()}, +\code{\link{rxUdfUiData}()}, +\code{\link{rxUdfUiEst}()}, +\code{\link{rxUdfUiIniLhs}()}, +\code{\link{rxUdfUiNum}()}, +\code{\link{rxUdfUiParsing}()} +} +\author{ +Matthew L. Fidler +} +\concept{User functions} diff --git a/man/rxUdfUiNum.Rd b/man/rxUdfUiNum.Rd new file mode 100644 index 000000000..07a5f5e48 --- /dev/null +++ b/man/rxUdfUiNum.Rd @@ -0,0 +1,33 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiNum} +\alias{rxUdfUiNum} +\title{This gives the current number in the ui of the particular function being called.} +\usage{ +rxUdfUiNum() +} +\value{ +integer greater than 1L +} +\description{ +If this is called outside of function parsing or the input is +unexpected this returns 1L. This is useful when writing replacement +UI functions +} +\examples{ + +rxUdfUiNum() +} +\seealso{ +Other User functions: +\code{\link{linMod}()}, +\code{\link{rxUdfUiData}()}, +\code{\link{rxUdfUiEst}()}, +\code{\link{rxUdfUiIniLhs}()}, +\code{\link{rxUdfUiMv}()}, +\code{\link{rxUdfUiParsing}()} +} +\author{ +Matthew L. Fidler +} +\concept{User functions} diff --git a/man/rxUdfUiParsing.Rd b/man/rxUdfUiParsing.Rd new file mode 100644 index 000000000..eab3e5877 --- /dev/null +++ b/man/rxUdfUiParsing.Rd @@ -0,0 +1,30 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiParsing} +\alias{rxUdfUiParsing} +\title{Returns if the current ui function is being parsed} +\usage{ +rxUdfUiParsing() +} +\value{ +logical if the current ui function is being parsed +} +\description{ +Returns if the current ui function is being parsed +} +\examples{ +rxUdfUiParsing() +} +\seealso{ +Other User functions: +\code{\link{linMod}()}, +\code{\link{rxUdfUiData}()}, +\code{\link{rxUdfUiEst}()}, +\code{\link{rxUdfUiIniLhs}()}, +\code{\link{rxUdfUiMv}()}, +\code{\link{rxUdfUiNum}()} +} +\author{ +Matthew L. Fidler +} +\concept{User functions} diff --git a/man/rxUdfUiReset.Rd b/man/rxUdfUiReset.Rd new file mode 100644 index 000000000..07f03800e --- /dev/null +++ b/man/rxUdfUiReset.Rd @@ -0,0 +1,21 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rudfui.R +\name{rxUdfUiReset} +\alias{rxUdfUiReset} +\title{Reset the rxode2 ui environment variables} +\usage{ +rxUdfUiReset() +} +\value{ +NULL silently +} +\description{ +Reset the rxode2 ui environment variables +} +\examples{ +rxUdfUiReset() +} +\author{ +Matthew L. Fidler +} +\keyword{internal} diff --git a/man/rxUiDeparse.Rd b/man/rxUiDeparse.Rd new file mode 100644 index 000000000..56ea4c029 --- /dev/null +++ b/man/rxUiDeparse.Rd @@ -0,0 +1,45 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/rxUiGet.R, R/rxsolve.R +\name{rxUiDeparse} +\alias{rxUiDeparse} +\alias{rxUiDeparse.lotriFix} +\alias{rxUiDeparse.default} +\alias{rxUiDeparse.rxControl} +\title{This is a generic function for deparsing certain objects when +printing out a rxode2 object. Currently it is used for any meta-information} +\usage{ +rxUiDeparse(object, var) + +\method{rxUiDeparse}{lotriFix}(object, var) + +\method{rxUiDeparse}{default}(object, var) + +\method{rxUiDeparse}{rxControl}(object, var) +} +\arguments{ +\item{object}{object to be deparsed} + +\item{var}{variable name to be assigned} +} +\value{ +parsed R expression that can be used for printing and +\code{as.function()} calls. +} +\description{ +This is a generic function for deparsing certain objects when +printing out a rxode2 object. Currently it is used for any meta-information + +rxUiDeparse.rxControl(rxControl(covsInterpolation="linear", method="dop853", +naInterpolation="nocb", keepInterpolation="nocb", sigmaXform="variance", +omegaXform="variance", returnType="data.frame", sumType="fsum", prodType="logify", +sensType="central"), "ctl") +} +\examples{ + +mat <- matrix(c(1, 0.1, 0.1, 1), 2, 2, dimnames=list(c("a", "b"), c("a", "b"))) + +rxUiDeparse(matrix(c(1, 0.1, 0.1, 1), 2, 2, dimnames=list(c("a", "b"), c("a", "b"))), "x") +} +\author{ +Matthew L. Fidler +} diff --git a/man/rxUiGet.Rd b/man/rxUiGet.Rd index 2acbd7e58..507705091 100644 --- a/man/rxUiGet.Rd +++ b/man/rxUiGet.Rd @@ -4,13 +4,18 @@ \alias{rxUiGet.cmtLines} \alias{rxUiGet.dvidLine} \alias{rxUiGet.paramsLine} +\alias{rxUiGet.interpLines} \alias{rxUiGet.simulationSigma} \alias{rxUiGet.simulationModel} \alias{rxUiGet.symengineModelNoPrune} \alias{rxUiGet.symengineModelPrune} \alias{rxUiGet.simulationIniModel} \alias{rxUiGet} -\alias{rxUiGet.params} +\alias{rxUiGet.levels} +\alias{rxUiGet.state} +\alias{rxUiGet.stateDf} +\alias{rxUiGet.statePropDf} +\alias{rxUiGet.props} \alias{rxUiGet.theta} \alias{rxUiGet.lstChr} \alias{rxUiGet.omega} @@ -45,6 +50,8 @@ \method{rxUiGet}{paramsLine}(x, ...) +\method{rxUiGet}{interpLines}(x, ...) + \method{rxUiGet}{simulationSigma}(x, ...) \method{rxUiGet}{simulationModel}(x, ...) @@ -57,7 +64,15 @@ rxUiGet(x, ...) -\method{rxUiGet}{params}(x, ...) +\method{rxUiGet}{levels}(x, ...) + +\method{rxUiGet}{state}(x, ...) + +\method{rxUiGet}{stateDf}(x, ...) + +\method{rxUiGet}{statePropDf}(x, ...) + +\method{rxUiGet}{props}(x, ...) \method{rxUiGet}{theta}(x, ...) diff --git a/man/rxode2.Rd b/man/rxode2.Rd index af364b4f2..908b50cc3 100644 --- a/man/rxode2.Rd +++ b/man/rxode2.Rd @@ -232,9 +232,6 @@ mod <- rxode2(\{ d/dt(centr) <- F*KA*depot - CL*C2 - Q*C2 + Q*C3; \}) }\if{html}{\out{}} - -\if{html}{\out{
}}\preformatted{## using C compiler: ‘gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0’ -}\if{html}{\out{
}} \itemize{ \item Inside a \code{rxode2("")} string statement: }\if{html}{\out{ @@ -250,9 +247,6 @@ mod <- rxode2(\{ d/dt(centr) <- F*KA*depot - CL*C2 - Q*C2 + Q*C3; ") }\if{html}{\out{}} - -\if{html}{\out{
}}\preformatted{## using C compiler: ‘gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0’ -}\if{html}{\out{
}} \itemize{ \item In a file name to be loaded by rxode2: }\if{html}{\out{ @@ -329,30 +323,11 @@ creates a parsed \code{rxode2} ui that can be translated to the \code{rxode2} compilation model. \if{html}{\out{
}}\preformatted{mod$simulationModel -}\if{html}{\out{
}} -\if{html}{\out{
}}\preformatted{## using C compiler: ‘gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0’ - -## rxode2 2.1.3.9000 model named rx_f0354f9c2871ad18f2498f9a38405373 model (ready). -## x$state: depot, center -## x$stateExtra: cp -## x$params: tka, tcl, tv, add.sd, eta.ka, eta.cl, eta.v, rxerr.cp -## x$lhs: ka, cl, v, cp, ipredSim, sim -}\if{html}{\out{
}} - -\if{html}{\out{
}}\preformatted{# or +# or mod$simulationIniModel }\if{html}{\out{
}} -\if{html}{\out{
}}\preformatted{## using C compiler: ‘gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0’ - -## rxode2 2.1.3.9000 model named rx_c7662da228e359bf543bec87fc5e25c9 model (ready). -## x$state: depot, center -## x$stateExtra: cp -## x$params: tka, tcl, tv, add.sd, eta.ka, eta.cl, eta.v, rxerr.cp -## x$lhs: ka, cl, v, cp, ipredSim, sim -}\if{html}{\out{
}} - This is the same type of function required for \code{nlmixr2} estimation and can be extended and modified by model piping. For this reason will be focused on in the documentation. @@ -371,7 +346,7 @@ printing statements (for debugging/testing). Assignment statements can be: \itemize{ \item \strong{simple} assignments, where the left hand is an identifier (i.e., -variable) +variable). This includes string assignments \item special \strong{time-derivative} assignments, where the left hand specifies the change of the amount in the corresponding state variable (compartment) with respect to time e.g., \code{d/dt(depot)}: @@ -392,6 +367,11 @@ compartment can be specified as \code{df(y)/dy(dy) = 1}. There may be some advantage to obtaining the solution or specifying the Jacobian for very stiff ODE systems. However, for the few stiff systems we tried with LSODA, this actually slightly slowed down the solving. +\item Special \strong{string value declarations} which tell what values a +string variable will take within a \code{rxode2} solving structure. These +values will then cause a factor to be created for this variable on +solving the \code{rxode2} model. As such, they are declared in much the +same way as \code{R}, that is: \code{labels(a) <- c("a1", "a2")}. } Note that assignment can be done by \code{=}, \verb{<-} or \code{~}. @@ -412,6 +392,12 @@ parameters are in a certain order instead of ordering the parameters by the order they are parsed. This is useful for keeping the parameter order the same when using 2 different ODE models. These are specified by \code{param(par1, par2,...)} +\item \strong{Variable interpolation statements}, which tells the interpolation +for specific covariates. These include \code{locf(cov1, cov2, ...)} for +last observation carried forward, \code{nocb(cov1, cov2, ...)} for next +observation carried backward, \code{linear(cov1, cov2, ...)} for linear +interpolation and \code{midpoint(cov1, cov2, ...)} for midpoint +interpolation. } An example model is shown below: @@ -468,7 +454,12 @@ assigned, or used as a state but can be accessed in the rxode2 code: \item \code{dvid} \item \code{addl} \item \code{ss} +\item \code{amt} +\item \code{dur} \item \code{rate} +\item \code{Rprintf} +\item \code{print} +\item \code{printf} \item \code{id} } @@ -1016,6 +1007,63 @@ In general all the that are supported are in the following table NA } +\section{Note on strings in rxode2}{ +Strings are converted to double values inside of \code{rxode2}, hence you can +refer to them as an integer corresponding to the string value or the +string value itself. For covariates these are calculated on the fly +based on your data and you should likely not try this, though you should +be aware. For strings defined in the model, this is fixed and both could +be used. + +For example: + +\if{html}{\out{
}}\preformatted{if (APGAR == 10 || APGAR == 8 || APGAR == 9) \{ + tAPGAR <- "High" + \} else if (APGAR == 1 || APGAR == 2 || APGAR == 3) \{ + tAPGAR <- "Low" + \} else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) \{ + tAPGAR <- "Med" + \} else \{ + tAPGAR<- "Med" + \} +}\if{html}{\out{
}} + +Could also be replaced by: + +\if{html}{\out{
}}\preformatted{if (APGAR == 10 || APGAR == 8 || APGAR == 9) \{ + tAPGAR <- "High" + \} else if (APGAR == 1 || APGAR == 2 || APGAR == 3) \{ + tAPGAR <- "Low" + \} else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) \{ + tAPGAR <- "Med" + \} else \{ + tAPGAR<- 3 + \} +}\if{html}{\out{
}} + +Since \code{"Med"} is already defined + +If you wanted you can pre-declare what levels it has (and the order) to +give you better control of this: + +\if{html}{\out{
}}\preformatted{levels(tAPGAR) <- c("Med", "Low", "High") +if (APGAR == 10 || APGAR == 8 || APGAR == 9) \{ + tAPGAR <- 3 + \} else if (APGAR == 1 || APGAR == 2 || APGAR == 3) \{ + tAPGAR <- 2 + \} else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) \{ + tAPGAR <- 1 + \} else \{ + tAPGAR<- 1 + \} +}\if{html}{\out{
}} + +You can see that the number changed since the declaration change the +numbers in each variable for \code{tAPGAR}. These \code{levels()} statements need +to be declared before the variable occurs to ensure the numbering is +consistent with what is declared. +} + \examples{ \donttest{ diff --git a/man/testIniDf.Rd b/man/testIniDf.Rd new file mode 100644 index 000000000..a82d79451 --- /dev/null +++ b/man/testIniDf.Rd @@ -0,0 +1,52 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/assert.R +\name{testIniDf} +\alias{testIniDf} +\alias{assertIniDf} +\title{This function tests if this object is a iniDf as needed by the UI} +\usage{ +testIniDf(iniDf) + +assertIniDf(iniDf, extra = "", .var.name = .vname(iniDf), null.ok = FALSE) +} +\arguments{ +\item{iniDf}{the object to test if it is a rxode2 ui \code{iniDf} data.frame} + +\item{extra}{information to append to the error message} + +\item{.var.name}{[\code{character(1)}]\cr +Name of the checked object to print in assertions. Defaults to +the heuristic implemented in \code{\link[checkmate]{vname}}.} + +\item{null.ok}{[\code{logical(1)}]\cr +If set to \code{TRUE}, \code{x} may also be \code{NULL}. +In this case only a type check of \code{x} is performed, all additional checks are disabled.} +} +\value{ +boolean, indicating if the object is a valid initialization data frame +} +\description{ +This function tests if this object is a iniDf as needed by the UI +} +\section{Functions}{ +\itemize{ +\item \code{assertIniDf()}: Assert that the object is a valid rxode2 ui initialization data frame + +}} +\examples{ +testIniDf(TRUE) +} +\seealso{ +Other Assertions: +\code{\link{assertCompartmentExists}()}, +\code{\link{assertCompartmentName}()}, +\code{\link{assertCompartmentNew}()}, +\code{\link{assertRxUi}()}, +\code{\link{assertVariableExists}()}, +\code{\link{assertVariableNew}()}, +\code{\link{testRxUnbounded}()} +} +\author{ +Matthew L. Fidler +} +\concept{Assertions} diff --git a/man/testRxUnbounded.Rd b/man/testRxUnbounded.Rd new file mode 100644 index 000000000..21b013508 --- /dev/null +++ b/man/testRxUnbounded.Rd @@ -0,0 +1,74 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/assert.R +\name{testRxUnbounded} +\alias{testRxUnbounded} +\alias{assertRxUnbounded} +\alias{warnRxBounded} +\title{Test if the rxode2 model has any parameters with user defined boundaries} +\usage{ +testRxUnbounded(ui) + +assertRxUnbounded(ui, extra = "", .var.name = .vname(ui)) + +warnRxBounded(ui, extra = "", .var.name = .vname(ui)) +} +\arguments{ +\item{ui}{rxode2 ui} + +\item{extra}{extra information to append to the error message} + +\item{.var.name}{variable name} +} +\value{ +boolean indicating if any parameters have user defined boundaries +} +\description{ +Test if the rxode2 model has any parameters with user defined boundaries +} +\section{Functions}{ +\itemize{ +\item \code{assertRxUnbounded()}: Assert that the rxode2 model has any parameters with user defined boundaries + +\item \code{warnRxBounded()}: Warn that the rxode2 model has any parameters with user defined boundaries + +}} +\examples{ + +one.cmt <- function() { + ini({ + tka <- 0.45; label("Ka") + tcl <- log(c(0, 2.7, 100)); label("Cl") + tv <- 3.45; label("V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) +} + +testRxUnbounded(one.cmt) + +try(assertRxUnbounded(one.cmt)) + +warnRxBounded(one.cmt) +} +\seealso{ +Other Assertions: +\code{\link{assertCompartmentExists}()}, +\code{\link{assertCompartmentName}()}, +\code{\link{assertCompartmentNew}()}, +\code{\link{assertRxUi}()}, +\code{\link{assertVariableExists}()}, +\code{\link{assertVariableNew}()}, +\code{\link{testIniDf}()} +} +\author{ +Matthew L. Fidler +} +\concept{Assertions} diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index 3e895b48b..0b891ec76 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -251,17 +251,6 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } -// forderForceBase -RObject forderForceBase(bool forceBase); -RcppExport SEXP _rxode2_forderForceBase(SEXP forceBaseSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< bool >::type forceBase(forceBaseSEXP); - rcpp_result_gen = Rcpp::wrap(forderForceBase(forceBase)); - return rcpp_result_gen; -END_RCPP -} // rxSetIni0 bool rxSetIni0(bool ini0); RcppExport SEXP _rxode2_rxSetIni0(SEXP ini0SEXP) { diff --git a/src/approx.c b/src/approx.c index a3f3bfc11..f585fb1cb 100644 --- a/src/approx.c +++ b/src/approx.c @@ -252,7 +252,11 @@ void _update_par_ptr(double t, unsigned int id, rx_solve *rx, int idxIn) { idx = j; } else if (isSameTimeOp(v, getTime(ind->ix[i], ind))) { idx = i; - } else if (op->is_locf == 2) { + } else if (op->instant_backward == 0) { + // use instant_backward to change the idx too; it does not + // change based on covariate + // backward=0=locf + // backward=1=nocb // nocb idx = j; } else { diff --git a/src/call_dvode.c b/src/call_dvode.c index 138eba097..a4c5cd807 100644 --- a/src/call_dvode.c +++ b/src/call_dvode.c @@ -9,9 +9,10 @@ #include "dop853.h" #define max(a, b) ((a) > (b) ? (a) : (b)) #define STRICT_R_HEADERS -#include +#include #include "../inst/include/rxode2.h" +iniPreciseSums //-------------------------------------------------------------------------- // These are now allocated via R structures in Rcpp. @@ -70,16 +71,6 @@ extern double rxode2_sumV(int n, ...){ return s; } -extern double rxode2_sumV_r(double *p, long double *pld, int m, int type, int n, ...){ - va_list valist; - va_start(valist, n); - for (unsigned int i = (unsigned int)n; i--;){ - p[i] = va_arg(valist, double); - } - va_end(valist); - return PreciseSums_sum_r(p, n, pld, m, type); -} - extern double rxode2_prod(double *input, int len){ return PreciseSums_prod(input, len); } diff --git a/src/codegen.c b/src/codegen.c index b91dfcd38..e7da220d0 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -341,13 +341,14 @@ void codegen(char *model, int show_ode, const char *prefix, const char *libname, if(tb.idu[i] != 0){ if (show_ode == ode_lag || show_ode == ode_dur || show_ode == ode_rate){ sAppendN(&sbOut, " ", 2); + int assignOne = 0; doDot(&sbOut, buf); sAppend(&sbOut, " = NA_REAL;\n", i, i); } else { // stateExtra sAppendN(&sbOut, " ", 2); doDot(&sbOut, buf); - sAppend(&sbOut, " = __zzStateVar__[%d]*((double)(_ON[%d]));\n", i, i); + sAppend(&sbOut, " = __zzStateVar__[__DDT%d__]*((double)(_ON[__DDT%d__]));\n", i, i); } } else { break; @@ -388,7 +389,8 @@ void codegen(char *model, int show_ode, const char *prefix, const char *libname, if (show_ode != ode_mexp && show_ode != ode_indLinVec){ if (sbPm.lProp[i] >= 0 ){ tb.ix = sbPm.lProp[i]; - if (tb.lh[tb.ix] == isLHS || tb.lh[tb.ix] == isLHSparam){ + if (tb.lh[tb.ix] == isLHS || tb.lh[tb.ix] == isLHSstr || + tb.lh[tb.ix] == isLHSparam){ sAppend(&sbOut," %s",show_ode == ode_dydt ? sbPm.line[i] : sbPmDt.line[i]); } } @@ -443,6 +445,8 @@ void codegen(char *model, int show_ode, const char *prefix, const char *libname, sAppend(&sbOut," %s", sbPm.line[i]); } break; + case TNONE: // no code is output (just props) + break; default: RSprintf("line Number: %d\n", i); RSprintf("type: %d\n", sbPm.lType[i]); @@ -481,7 +485,7 @@ void codegen(char *model, int show_ode, const char *prefix, const char *libname, for (i = 0; i < tb.de.n; i++) { if (tb.idu[i]) { buf=tb.ss.line[tb.di[i]]; - sAppend(&sbOut, " __zzStateVar__[%d]=((double)(_ON[%d]))*(",i,i); + sAppend(&sbOut, " __zzStateVar__[__DDT%d__]=((double)(_ON[__DDT%d__]))*(",i,i); doDot(&sbOut, buf); sAppendN(&sbOut, ");\n", 3); } @@ -494,7 +498,8 @@ void codegen(char *model, int show_ode, const char *prefix, const char *libname, } else if (show_ode == ode_lhs && tb.li){ sAppendN(&sbOut, "\n", 1); for (i=0, j=0; i 0) { + SEXP stateOrdNames = PROTECT(Rf_getAttrib(stateOrd, R_NamesSymbol)); pro++; + int *stateOrdInt = INTEGER(stateOrd); + sAppend(&sbOut, "// Define translation state order for %d states\n", Rf_length(stateOrd)); + for (int i = 0; i < nOrd; i++){ + sAppend(&sbOut, "#define __DDT%d__ %d // %s\n", stateOrdInt[i]-1, i, + CHAR(STRING_ELT(stateOrdNames, i))); + } + writeSb(&sbOut, fpIO); + sbOut.o = 0; + } + UNPROTECT(pro); // show_ode = 1 dydt // show_ode = 2 Jacobian // show_ode = 3 Ini statement @@ -666,6 +686,7 @@ SEXP _rxode2_codegen(SEXP c_file, SEXP prefix, SEXP libname, sAppend(&sbOut, "#define _CENTRAL_ %d\n", tb.statei); } writeSb(&sbOut, fpIO); + sbOut.o = 0; } gCode(1); // d/dt() gCode(2); // jac diff --git a/src/codegen.h b/src/codegen.h index c8045e77e..ac9693915 100644 --- a/src/codegen.h +++ b/src/codegen.h @@ -103,8 +103,8 @@ static inline int isStateLhsI(int i) { int doCont=0; for (int j = 0; j < tb.de.n; j++) { if (tb.di[j] == i) { - if (!tb.idu[j]) doCont = 1; - break; + if (!tb.idu[j]) doCont = 1; + break; } } if (doCont) return 1; @@ -118,9 +118,10 @@ static inline int shouldSkipPrintLhsI(int scenario, int lhs, int i) { case print_paramLags: return (tb.lag[i] == notLHS || tb.lh[i] == isState); case print_lhsLags: - return (tb.lag[i] == 0 || tb.lh[i] != isLHS); + return (tb.lag[i] == 0 || (tb.lh[i] != isLHS && tb.lh[i] != isLHSstr)); case print_lastLhsValue: - return !(tb.lh[i] == isLHS || tb.lh[i] == isLhsStateExtra || tb.lh[i] == isLHSparam); + return !(tb.lh[i] == isLHS || tb.lh[i] == isLHSstr || + tb.lh[i] == isLhsStateExtra || tb.lh[i] == isLHSparam); } return (lhs && tb.lh[i]>0 && tb.lh[i] != isLHSparam); } diff --git a/src/cvPost.cpp b/src/cvPost.cpp index aee7ff44a..a84247775 100644 --- a/src/cvPost.cpp +++ b/src/cvPost.cpp @@ -10,25 +10,12 @@ #include #include "../inst/include/rxode2parse.h" #include "../inst/include/rxode2_as.h" +#include -extern "C"{ - - extern "C" SEXP chin(SEXP a, SEXP b); - typedef SEXP (*lotriMat_type) (SEXP, SEXP, SEXP); - lotriMat_type lotriMat; - typedef SEXP (*asLotriMat_type) (SEXP, SEXP, SEXP); - asLotriMat_type asLotriMat; - typedef SEXP (*lotriSep_type) (SEXP, SEXP, SEXP, SEXP, SEXP); - lotriSep_type lotriSep; - typedef SEXP (*lotriAllNames_type) (SEXP); - lotriAllNames_type lotriAllNames; - typedef SEXP (*lotriGetBounds_type) (SEXP, SEXP, SEXP); - lotriGetBounds_type lotriGetBounds; - typedef SEXP (*isLotri_type) (SEXP); - isLotri_type isLotri; - typedef SEXP (*lotriMaxNu_type) (SEXP); - lotriMaxNu_type lotriMaxNu; +extern "C" { + iniLotri; } + List etTrans(List inData, const RObject &mv, bool addCmt, bool dropUnits, bool allTimeVar, bool keepDosingOnly, Nullable combineDvid, @@ -62,19 +49,6 @@ LogicalVector rxSolveFree(); bool gotLotriMat=false; -static inline void setupLotri() { - if (!gotLotriMat) { - lotriMat = (lotriMat_type) R_GetCCallable("lotri","_lotriLstToMat"); - asLotriMat = (asLotriMat_type) R_GetCCallable("lotri","_asLotriMat"); - lotriSep = (lotriSep_type) R_GetCCallable("lotri","_lotriSep"); - lotriAllNames = (lotriAllNames_type) R_GetCCallable("lotri","_lotriAllNames"); - lotriGetBounds = (lotriGetBounds_type) R_GetCCallable("lotri", "_lotriGetBounds"); - isLotri = (isLotri_type) R_GetCCallable("lotri", "_isLotri"); - lotriMaxNu = (lotriMaxNu_type) R_GetCCallable("lotri", "_lotriMaxNu"); - gotLotriMat=true; - } -} - using namespace Rcpp; using namespace arma; @@ -411,7 +385,6 @@ SEXP cvPost_(SEXP nuS, SEXP omegaS, SEXP nS, SEXP omegaIsCholS, } else { stop(_("variable 'type': Can only use type string or integer[1,3]")); } - setupLotri(); if (n == 1 && type == 1){ if (qtest(omegaS, "M")) { double nu = getDbl(nuS, "nu"); @@ -485,8 +458,9 @@ SEXP cvPost_(SEXP nuS, SEXP omegaS, SEXP nS, SEXP omegaIsCholS, if (omega.hasAttribute("format")) { format = omega.attr("format"); } - setupLotri(); - return as(lotriMat(as(omegaLst), format, as(startAt))); + return as(lotriLstToMat(as(omegaLst), format, + as(startAt), + as(CharacterVector::create("matrix", "array")))); } } else { if (type == 1){ @@ -676,11 +650,12 @@ SEXP expandTheta_(SEXP thetaS, SEXP thetaMatS, return as(ret); } - +Function getRxFn(std::string name); static inline int getMethodInt(std::string& methodStr, CharacterVector& allNames, SEXP et) { int methodInt=1; if (methodStr == "auto") { // FIXME don't use %in%/%chin% from R + Function chin = getRxFn(".chin"); LogicalVector inL = as(chin(allNames, Rf_getAttrib(et, R_NamesSymbol))); bool allIn = true; for (int j = inL.size(); j--;){ @@ -715,7 +690,6 @@ SEXP expandPars_(SEXP objectS, SEXP paramsS, SEXP eventsS, SEXP controlS) { // SEXP events = as(events); qassertS(controlS, "l+", "control"); List control = as(controlS); - setupLotri(); int pro = 0; SEXP nStudS = PROTECT(control[Rxc_nStud]); pro++; int nStud = as(nStudS); @@ -1167,7 +1141,6 @@ SEXP nestingInfo_(SEXP omega, List data) { if (Rf_isNewList(omega)){ lotriOmega = omega; } else if (Rf_isMatrix(omega)) { - setupLotri(); lotriOmega = PROTECT(asLotriMat(omega, R_NilValue, wrap(CharacterVector::create(idName)))); pro++; } else { diff --git a/src/et.cpp b/src/et.cpp index 7c93dfc02..0b02b89f3 100644 --- a/src/et.cpp +++ b/src/et.cpp @@ -14,6 +14,8 @@ extern "C" rx_solving_options op_global; using namespace Rcpp; +Function getRxFn(std::string name); + SEXP convertId_(SEXP id); extern "C" int _rxIsEt(SEXP objSexp); @@ -43,10 +45,15 @@ static inline bool rxIsCleanList(RObject obj) { #endif Environment rxode2env (); -Function getRxFn(std::string name); -extern "C" SEXP getForder(void); -extern "C" int useForder(void); +extern "C" SEXP orderForderS1(SEXP ordIn) { +BEGIN_RCPP + Function order1 = getRxFn(".order1"); + IntegerVector ord = order1(ordIn); + return wrap(ord); +END_RCPP +} + RObject evCur; RObject curSolve; @@ -413,21 +420,13 @@ List etSort(List& curEt){ IntegerVector ivId=wrap(id); NumericVector nvTime=wrap(time); IntegerVector ivEvid=wrap(evid); - Function order = getForder(); + Function order3 = getRxFn(".order3"); IntegerVector ord; - if (useForder()){ - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(0)); - } else { - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(0), - _["method"]="radix"); - } + ord = order3(ivId, nvTime, ivEvid); ord = ord - 1; idx = as>(ord); List newEt(curEt.size()); int i, j, newSize = time.size(); - bool naTime=false; for (int j = time.size(); j--;) { if (ISNA(time[j])) { newSize--; @@ -575,16 +574,9 @@ List etAddWindow(List windowLst, IntegerVector IDs, RObject cmt, bool turnOnShow IntegerVector ivId=wrap(id); NumericVector nvTime=wrap(time); IntegerVector ivEvid=wrap(evid); - Function order = getForder(); + Function order3 = getRxFn(".order3"); IntegerVector ord; - if (useForder()){ - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL)); - } else { - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL), - _["method"]="radix"); - } + ord = order3(ivId, nvTime, ivEvid); ord = ord - 1; idx = as>(ord); List lst(curEt.size()); @@ -1514,16 +1506,9 @@ List etExpandAddl(List curEt){ IntegerVector ivId=wrap(id); NumericVector nvTime=wrap(time); IntegerVector ivEvid=wrap(evid); - Function order = getForder(); + Function order3 = getRxFn(".order3"); IntegerVector ord; - if (useForder()){ - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL)); - } else { - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL), - _["method"]="radix"); - } + ord = order3(ivId, nvTime, ivEvid); ord = ord - 1; idx = as>(ord); List lst(curEt.size()); @@ -1696,16 +1681,8 @@ List etAddDose(NumericVector curTime, RObject cmt, double amt, double rate, dou IntegerVector ivId=wrap(id); NumericVector nvTime=wrap(time); IntegerVector ivEvid=wrap(evid); - Function order = getForder(); - IntegerVector ord; - if (useForder()){ - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL)); - } else { - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL), - _["method"]="radix"); - } + Function order3 = getRxFn(".order3"); + IntegerVector ord = order3(ivId, nvTime, ivEvid); ord = ord - 1; idx = as>(ord); @@ -3130,6 +3107,8 @@ RObject et_(List input, List et__) { return ret; } +Function getRxFn(std::string name); + // Sequence event tables //[[Rcpp::export]] List etSeq_(List ets, int handleSamples=0, int waitType = 0, @@ -3369,16 +3348,9 @@ List etSeq_(List ets, int handleSamples=0, int waitType = 0, IntegerVector ivId=wrap(id); NumericVector nvTime=wrap(time); IntegerVector ivEvid=wrap(evid); - Function order = getForder(); + Function order3 = getRxFn(".order3"); IntegerVector ord; - if (useForder()){ - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL)); - } else { - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL), - _["method"]="radix"); - } + ord = order3(ivId, nvTime, ivEvid); ord = ord - 1; idx = as>(ord); } diff --git a/src/etTran.cpp b/src/etTran.cpp index 0ccfabb37..d68868011 100644 --- a/src/etTran.cpp +++ b/src/etTran.cpp @@ -118,34 +118,8 @@ static inline bool asBool(SEXP in, const char *what) { } Function getRxFn(std::string name); -Environment rxode2env(); - -Environment dataTable; -bool getForder_b=false; -Function getRxFn(std::string name); -bool dtForder = false; -bool forderForceBase_ = false; -//' Force using base order for rxode2 radix sorting -//' -//' @param forceBase boolean indicating if rxode2 should use R's -//' [order()] for radix sorting instead of -//' `data.table`'s parallel radix sorting. -//' -//' @return NILL; called for side effects -//' -//' @examples -//' \donttest{ -//' forderForceBase(TRUE) # Use base `order` for rxode2 sorts -//' forderForceBase(FALSE) # Use `data.table` for rxode2 sorts -//' } -//' @export -//' @keywords internal -//[[Rcpp::export]] -RObject forderForceBase(bool forceBase = false){ - forderForceBase_=forceBase; - return R_NilValue; -} +Environment rxode2env(); IntegerVector convertDvid_(SEXP inCmt, int maxDvid=0){ IntegerVector id = asIv(inCmt, "inCmt"); @@ -156,42 +130,6 @@ IntegerVector convertDvid_(SEXP inCmt, int maxDvid=0){ } return id; } -extern "C" SEXP getForder(void) { - if (!getForder_b){ - Function fn = getRxFn(".getDTEnv"); - dataTable = fn(); - getForder_b=true; - } - if (!forderForceBase_ && dataTable.exists("forder")){ - dtForder=true; - return wrap(dataTable["forder"]); - } - Environment b=Rcpp::Environment::base_namespace(); - dtForder=false; - return wrap(b["order"]); -} - -Function getChin() { - if (!getForder_b){ - Function fn = getRxFn(".getDTEnv"); - dataTable = fn(); - getForder_b=true; - } - if (!forderForceBase_ && dataTable.exists("%chin%")){ - return dataTable["%chin%"]; - } - Environment b=Rcpp::Environment::base_namespace(); - return b["%in%"]; -} - -extern "C" SEXP chin(SEXP x, SEXP table) { - Function chin_ = getChin(); - return chin_(x, table); -} - -extern "C" int useForder(void){ - return (int)(getForder_b); -} IntegerVector toCmt(RObject inCmt, CharacterVector& state, const bool isDvid, const int stateSize, const int sensSize, IntegerVector& curDvid, @@ -825,19 +763,22 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, NumericVector nvTmp, nvTmp2; bool hasCmt = false; int cmtI =0; + List strAssign = mv[RxMv_strAssign]; + List strAssignN = strAssign.names(); List inDataF(covCol.size()); - List inDataLvl(covCol.size()); + List inDataLvlN(covCol.size()+strAssign.size()); + List inDataLvl(covCol.size()+strAssign.size()); for (i = covCol.size(); i--;){ int covColi = covCol[i]; if (covColi >= 0) { - covUnitsN[i] = lName[covColi]; + inDataLvlN[i] = covUnitsN[i] = lName[covColi]; } else { // Get from iCov; when found the i was pushed back as: // covCol.push_back(-i-1); // Using some algebra you have // -i-1 = covColi // i = -covColi-1 - covUnitsN[i] = liName[-covColi-1]; + inDataLvlN[i] = covUnitsN[i] = liName[-covColi-1]; } nvTmp2 = NumericVector::create(1.0); if (hasCmt || covColi >= 0 && as(lName[covColi]) != "cmt"){ @@ -869,7 +810,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } covUnits[i] = nvTmp2; } - Rf_setAttrib(inDataLvl, R_NamesSymbol, covUnitsN); + for (i = 0; i < strAssign.size(); ++i){ + inDataLvlN[i+covCol.size()] = strAssignN[i]; + inDataLvl[i+covCol.size()] = strAssign[i]; + } + Rf_setAttrib(inDataLvl, R_NamesSymbol, inDataLvlN); Rf_setAttrib(covUnits, R_NamesSymbol, covUnitsN); // EVID = 0; Observations // EVID = 1; is illegal, but converted from NONMEM @@ -980,7 +925,6 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, std::vector dv; dv.reserve(resSize); std::vector idxOutput; - idxOutput.reserve(resSize); std::vector idxIcov; std::vector cens; cens.reserve(resSize); @@ -1185,7 +1129,6 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, double cii; double dur =0.0; double camt; - int curIdx=0; double cdv, climit; int nobs=0, ndose=0; @@ -1206,6 +1149,10 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, bool hasReset = false; double maxShift = 0; bool warnNaTime=false; + // This section of the code: + // - Loops over the input dataset + // - Changes nonmem-style evid to classic rxode events + // - adds infusion endings and additional doses for (int i = 0; i < inTime.size(); i++) { if (idCol == -1) cid = 1; else cid = inId[i]; @@ -1233,7 +1180,7 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } else if (lastId != cid) { lastId = cid; } else if (lastTime > ctime) { - if (inEvid[i] != 3 && inEvid[i] != 4) { + if (!hasEvid || (inEvid[i] != 3 && inEvid[i] != 4)) { isSorted = false; // The prior EVID=3 w/reset a reset time // REprintf("\t not sorted"); } else if (lastTime > ctime) { @@ -1269,8 +1216,8 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, dv.push_back(NA_REAL); cens.push_back(0); limit.push_back(NA_REAL); + idxInput.push_back(-1); - idxOutput.push_back(curIdx);curIdx++; } nid++; } @@ -1525,7 +1472,6 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } amt.push_back(NA_REAL); ii.push_back(0.0); - idxInput.push_back(i); cens.push_back(ccens); if (ccens!=0) censNone=false; if (ccens == 1 && !std::isinf(climit)){ @@ -1544,7 +1490,8 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, dv.push_back(cdv); limit.push_back(climit); } - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(i); cevid = -1; } break; @@ -1594,11 +1541,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } amt.push_back(NA_REAL); ii.push_back(0.0); - idxInput.push_back(i); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(i); ndose++; // + cmt needs to turn on cmts. // This gives a zero dose to cmt @@ -1610,11 +1557,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime); amt.push_back(0.0); ii.push_back(0.0); - idxInput.push_back(i); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(i); ndose++; } cevid = -1; @@ -1640,11 +1587,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } amt.push_back(NA_REAL); ii.push_back(0.0); - idxInput.push_back(i); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(i); ndose++; cevid = -1; break; @@ -1668,11 +1615,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } amt.push_back(NA_REAL); ii.push_back(0.0); - idxInput.push_back(-1); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(-1); ndose++; // Now use the transformed compartment cevid = cmt100*100000+rateI*10000+cmt99*100+flg; @@ -1737,11 +1684,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, keepIIadl = true; //stop(_("'ss' with 'addl' not supported (id: %s row: %d)"), CHAR(idLvl[cid-1]), i+1); } - idxInput.push_back(i); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(i); ndose++; if (rateI > 2 && rateI != 4 && rateI != 5 && flg != 40){ // modeled rate/duration @@ -1764,11 +1711,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime); //ii.push_back(cii); ii.push_back(0.0); - idxInput.push_back(-1); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(-1); ndose++; } // turn off @@ -1778,11 +1725,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime); amt.push_back(camt); ii.push_back(0.0); - idxInput.push_back(-1); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(-1); ndose++; } else if (rateI == 1 || rateI == 2){ // In this case amt needs to be changed. @@ -1800,11 +1747,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, amt.push_back(-rate); time.push_back(ctime); ii.push_back(cii); - idxInput.push_back(-1); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(-1); ndose++; nevidLag = cmt100*100000+rateI*10000+cmt99*100+1; @@ -1815,11 +1762,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime); //ii.push_back(cii); ii.push_back(0.0); - idxInput.push_back(-1); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(-1); ndose++; } // turn off @@ -1834,11 +1781,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime+dur); amt.push_back(-rate); ii.push_back(0.0); - idxInput.push_back(-1); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(-1); ndose++; } } else { @@ -1855,11 +1802,11 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime); //ii.push_back(cii); ii.push_back(0.0); - idxInput.push_back(-1); dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; + + idxInput.push_back(-1); ndose++; } } @@ -1894,15 +1841,15 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } else { ii.push_back(0.0); } + dv.push_back(NA_REAL); + limit.push_back(NA_REAL); + cens.push_back(0); + if (addlKeepsCov) { idxInput.push_back(i); } else { idxInput.push_back(-1); } - dv.push_back(NA_REAL); - limit.push_back(NA_REAL); - cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; ndose++; if (rateI > 2 && rateI != 4 && rateI != 5) { amt.push_back(camt); @@ -1912,16 +1859,16 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, cmtF.push_back(cmt); time.push_back(ctime); ii.push_back(0.0); + dv.push_back(NA_REAL); + limit.push_back(NA_REAL); + cens.push_back(0); + amt.push_back(camt); + if (addlKeepsCov) { idxInput.push_back(i); } else { idxInput.push_back(-1); } - dv.push_back(NA_REAL); - limit.push_back(NA_REAL); - cens.push_back(0); - amt.push_back(camt); - idxOutput.push_back(curIdx);curIdx++; ndose++; } // turn off @@ -1931,15 +1878,15 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime); amt.push_back(camt); ii.push_back(0.0); + dv.push_back(NA_REAL); + limit.push_back(NA_REAL); + cens.push_back(0); + if (addlKeepsCov) { idxInput.push_back(i); } else { idxInput.push_back(-1); } - dv.push_back(NA_REAL); - limit.push_back(NA_REAL); - cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; ndose++; } else if (rateI == 1 || rateI == 2){ amt.push_back(rate); @@ -1955,15 +1902,15 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, ii.push_back(0.0); } //ii.push_back(0.0); + dv.push_back(NA_REAL); + limit.push_back(NA_REAL); + cens.push_back(0); + if (addlKeepsCov) { idxInput.push_back(i); } else { idxInput.push_back(-1); } - dv.push_back(NA_REAL); - limit.push_back(NA_REAL); - cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; ndose++; id.push_back(cid); @@ -1971,16 +1918,16 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, cmtF.push_back(cmt); time.push_back(ctime); ii.push_back(0.0); + dv.push_back(NA_REAL); + limit.push_back(NA_REAL); + cens.push_back(0); + amt.push_back(rate); + if (addlKeepsCov) { idxInput.push_back(i); } else { idxInput.push_back(-1); } - dv.push_back(NA_REAL); - limit.push_back(NA_REAL); - cens.push_back(0); - amt.push_back(rate); - idxOutput.push_back(curIdx);curIdx++; ndose++; } // turn off @@ -1994,16 +1941,15 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, time.push_back(ctime+dur); amt.push_back(-rate); ii.push_back(0.0); + dv.push_back(NA_REAL); + limit.push_back(NA_REAL); + cens.push_back(0); + if (addlKeepsCov) { idxInput.push_back(i); } else { idxInput.push_back(-1); } - idxInput.push_back(-1); - dv.push_back(NA_REAL); - limit.push_back(NA_REAL); - cens.push_back(0); - idxOutput.push_back(curIdx);curIdx++; ndose++; } else { amt.push_back(camt); @@ -2013,16 +1959,16 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, cmtF.push_back(cmt); time.push_back(ctime); ii.push_back(0.0); + dv.push_back(NA_REAL); + limit.push_back(NA_REAL); + cens.push_back(0); + amt.push_back(camt); + if (addlKeepsCov) { idxInput.push_back(i); } else { idxInput.push_back(-1); } - dv.push_back(NA_REAL); - limit.push_back(NA_REAL); - cens.push_back(0); - amt.push_back(camt); - idxOutput.push_back(curIdx);curIdx++; ndose++; } } @@ -2101,8 +2047,8 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, dv.push_back(NA_REAL); limit.push_back(NA_REAL); cens.push_back(0); + idxInput.push_back(-1); - idxOutput.push_back(curIdx);curIdx++; } } } @@ -2118,6 +2064,7 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, IntegerVector ivId = wrap(id); NumericVector nvTime = wrap(time); IntegerVector ivEvid = clone(wrap(evid)); + if (!keepDosingOnly && doseId.size() > 0){ #define sortID if (ivEvid[j]==3){ \ ivEvid[j] = NA_INTEGER+1; \ @@ -2139,41 +2086,25 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } } #undef sortID - Function order = as(getForder()); + Function order3 = getRxFn(".order3"); + Function order1 = getRxFn(".order1"); IntegerVector ord; IntegerVector ordI; - if (useForder()){ - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(true)); - ord = ord - 1; - // na.last isn't =NA isn't quite working - idxOutput = as>(ord); - while (idxOutput.size() > 0 && IntegerVector::is_na(ivId[idxOutput.back()])){ - idxOutput.pop_back(); - } - if (hasIcov) { - ordI = order(inIdCov, _["na.last"] = LogicalVector::create(true)); - ordI = ordI-1; - idxIcov = as>(ordI); - } - } else { - ord = order(ivId, nvTime, ivEvid, - _["na.last"] = LogicalVector::create(NA_LOGICAL), - _["method"]="radix"); - ord = ord - 1; - idxOutput = as>(ord); - if (hasIcov) { - ordI = order(inIdCov, _["na.last"] = LogicalVector::create(true), - _["method"]="radix"); - ordI = ordI-1; - idxIcov = as>(ordI); - } + ord = order3(ivId, nvTime, ivEvid); + ord = ord - 1; + idxOutput = as>(ord); + while (idxOutput.size() > 0 && IntegerVector::is_na(ivId[idxOutput.back()])){ + idxOutput.pop_back(); + } + if (hasIcov) { + ordI = order1(inIdCov); + ordI = ordI-1; + idxIcov = as>(ordI); } #ifdef rxSolveT REprintf(" Time8: %f\n", ((double)(clock() - _lastT0))/CLOCKS_PER_SEC); _lastT0 = clock(); #endif - if (idxOutput.size()==0) stop(_("no rows in event table or input data")); lastId = id[idxOutput.back()]+42; int rmAmt = 0; @@ -2312,6 +2243,7 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, CharacterVector keepN(keepCol.size()); IntegerVector keepLc(keepCol.size()); for (j = 0; j < (int)(keepCol.size()); j++){ + // size = the same size as the output with exception of the rmAmt or tr keepL[j] = NumericVector(idxOutput.size()-rmAmt); int keepColj = keepCol[j]; const char* cmp; @@ -2347,7 +2279,7 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, bool calcIcovKeepIdx = false; IntegerVector iCovKeepIdx; std::vector covParInterpMv = as>(mv[RxMv_interp]); - for (j = 0; j < (int)(keepCol.size()); j++){ + for (j = 0; j < (int)(keepCol.size()); j++) { int keepColj = keepCol[j]; SEXP cur; if (keepColj >= 0) { @@ -2473,7 +2405,7 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, jj--; ivTmp = as(lst[0]); ivTmp[jj] = id[idxOutput[i]]; - if (lastId != id[idxOutput[i]]){ + if (lastId != id[idxOutput[i]]) { maxItemsPerId = max2(curItems, maxItemsPerId); curItems=0; addId=true; @@ -2516,18 +2448,16 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } // Now add the other items. added=false; - for (j = 0; j < (int)(keepCol.size()); j++){ - // idxOutput is the output id - nvTmp = as(keepL[j]); - if (idxInput[idxOutput[i]] == -1) { // Not in data. - // Implement LOCF - if (addId){ - nvTmp[jj] = NA_REAL; - } else { - // LOCF - nvTmp[jj] = nvTmp[jj-1]; - } - } else { + if (idxInput[idxOutput[i]] == -1) { + // not in data + for (j = 0; j < (int)(keepCol.size()); j++){ + nvTmp = as(keepL[j]); + nvTmp[jj] = NA_REAL; + } + } else { + for (j = 0; j < (int)(keepCol.size()); j++){ + // idxOutput is the output id + nvTmp = as(keepL[j]); // These keep variables are added. SEXP cur = inDataFK[j]; nvTmp[jj] = REAL(cur)[idxInput[idxOutput[i]]]; @@ -2535,7 +2465,7 @@ List etTrans(List inData, const RObject &obj, bool addCmt=false, } for (j = 0; j < (int)(covCol.size()); j++){ int covColj = covCol[j]; - if (hasCmt && covColj >= 0 &&j == cmtI){ + if (hasCmt && covColj >= 0 &&j == cmtI) { ivTmp = as(lst[baseSize+j]); ivTmp[jj] = cmtF[idxOutput[i]]; if (!cmtFadd){ diff --git a/src/genModelVars.c b/src/genModelVars.c index 5099be9a6..d565ffcdd 100644 --- a/src/genModelVars.c +++ b/src/genModelVars.c @@ -9,8 +9,8 @@ SEXP generateModelVars(void) { calcNextra(); int pro = 0; - SEXP lst = PROTECT(Rf_allocVector(VECSXP, 22));pro++; - SEXP names = PROTECT(Rf_allocVector(STRSXP, 22));pro++; + SEXP lst = PROTECT(Rf_allocVector(VECSXP, 28));pro++; + SEXP names = PROTECT(Rf_allocVector(STRSXP, 28));pro++; SEXP sNeedSort = PROTECT(Rf_allocVector(INTSXP,1));pro++; int *iNeedSort = INTEGER(sNeedSort); @@ -26,23 +26,35 @@ SEXP generateModelVars(void) { SEXP trann = PROTECT(Rf_allocVector(STRSXP, 22));pro++; SEXP state = PROTECT(Rf_allocVector(STRSXP,tb.statei-tb.nExtra));pro++; + SEXP stateProp = PROTECT(Rf_allocVector(INTSXP,tb.statei-tb.nExtra));pro++; + SEXP stateRmS = PROTECT(Rf_allocVector(INTSXP,tb.statei-tb.nExtra));pro++; int *stateRm = INTEGER(stateRmS); SEXP extraState = PROTECT(Rf_allocVector(STRSXP,tb.nExtra));pro++; - SEXP sens = PROTECT(Rf_allocVector(STRSXP,tb.sensi));pro++; - SEXP normState= PROTECT(Rf_allocVector(STRSXP,tb.statei-tb.sensi-tb.nExtra));pro++; - - populateStateVectors(state, sens, normState, stateRm, extraState); - + SEXP sens = PROTECT(Rf_allocVector(STRSXP,tb.sensi));pro++; + SEXP sensProp = PROTECT(Rf_allocVector(INTSXP,tb.sensi));pro++; + + SEXP normState = PROTECT(Rf_allocVector(STRSXP,tb.statei-tb.sensi-tb.nExtra));pro++; + SEXP normProp = PROTECT(Rf_allocVector(INTSXP,tb.statei-tb.sensi-tb.nExtra));pro++; + + SEXP ordS = PROTECT(Rf_allocVector(INTSXP, tb.de.n));pro++; + SEXP ordF = PROTECT(sortStateVectors(ordS)); pro++; + if (Rf_isNull(ordF)) { + UNPROTECT(pro); + trans_syntax_error_report_fn0(_gbuf.s); + return R_NilValue; + } + populateStateVectors(state, sens, normState, stateRm, extraState, stateProp, sensProp, normProp, INTEGER(ordF)); SEXP dfdy = PROTECT(Rf_allocVector(STRSXP,tb.ndfdy));pro++; populateDfdy(dfdy); - SEXP params = PROTECT(Rf_allocVector(STRSXP, tb.pi));pro++; SEXP lhs = PROTECT(Rf_allocVector(STRSXP, tb.li));pro++; + SEXP lhsStr = PROTECT(Rf_allocVector(LGLSXP, tb.li));pro++; SEXP slhs = PROTECT(Rf_allocVector(STRSXP, tb.sli));pro++; SEXP interp = PROTECT(Rf_allocVector(INTSXP, tb.pi));pro++; + SEXP version = PROTECT(calcVersionInfo());pro++; SEXP ini = PROTECT(calcIniVals()); pro++; @@ -50,7 +62,7 @@ SEXP generateModelVars(void) { SEXP model = PROTECT(Rf_allocVector(STRSXP,2));pro++; SEXP modeln = PROTECT(Rf_allocVector(STRSXP,2));pro++; - populateParamsLhsSlhs(params, lhs, slhs, INTEGER(interp)); + populateParamsLhsSlhs(params, lhs, slhs, INTEGER(interp), lhsStr); INTEGER(sLinCmt)[5] = tb.hasCmt; @@ -243,6 +255,46 @@ SEXP generateModelVars(void) { SET_VECTOR_ELT(lst, 21, interp); SET_STRING_ELT(names, 21, mkChar("interp")); + SEXP strAssign = PROTECT(Rf_allocVector(VECSXP, tb.str.n));pro++; + SEXP strAssignN = PROTECT(Rf_allocVector(STRSXP, tb.str.n));pro++; + for (int i = 0; i < tb.str.n; i++) { + SEXP cur = PROTECT(Rf_allocVector(STRSXP, tb.sin[i]));pro++; + int k = 0; + for (int j = 0; j < tb.strVal.n; j++) { + if (tb.strValI[j] == i) { + SET_STRING_ELT(cur, k, mkChar(tb.strVal.line[j])); + k++; + } + } + SET_VECTOR_ELT(strAssign, i, cur); + SET_STRING_ELT(strAssignN, i, mkChar(tb.str.line[i])); + } + Rf_setAttrib(strAssign, R_NamesSymbol, strAssignN); + Rf_setAttrib(lhsStr, R_NamesSymbol, lhs); + + + SET_VECTOR_ELT(lst, 22, strAssign); + SET_STRING_ELT(names, 22, mkChar("strAssign")); + + SET_VECTOR_ELT(lst, 23, lhsStr); + SET_STRING_ELT(names, 23, mkChar("lhsStr")); + + Rf_setAttrib(stateProp, R_NamesSymbol, state); + SET_VECTOR_ELT(lst, 24, stateProp); + SET_STRING_ELT(names, 24, mkChar("stateProp")); + + Rf_setAttrib(sensProp, R_NamesSymbol, sens); + SET_VECTOR_ELT(lst, 25, sensProp); + SET_STRING_ELT(names, 25, mkChar("sensProp")); + + Rf_setAttrib(normProp, R_NamesSymbol, normState); + SET_VECTOR_ELT(lst, 26, normProp); + SET_STRING_ELT(names, 26, mkChar("normProp")); + + Rf_setAttrib(ordF, R_NamesSymbol, state); + SET_VECTOR_ELT(lst, 27, ordF); + SET_STRING_ELT(names, 27, mkChar("stateOrd")); + Rf_setAttrib(tran, R_NamesSymbol, trann); Rf_setAttrib(lst, R_NamesSymbol, names); Rf_setAttrib(model, R_NamesSymbol, modeln); diff --git a/src/genModelVars.h b/src/genModelVars.h index 55d7d0348..2395c2634 100644 --- a/src/genModelVars.h +++ b/src/genModelVars.h @@ -76,10 +76,22 @@ static inline void calcNparamsNlhsNslhs(void) { int sli=0, li=0, pi=0; for (int i=0; i1 && islhs != isLhsStateExtra && islhs != isLHSparam && islhs != isSuppressedLHS) continue; /* is a state var */ - if (islhs == isSuppressedLHS){ + if (islhs>1 && + islhs != isLhsStateExtra && + islhs != isLHSparam && + islhs != isSuppressedLHS && + islhs != isLHSstr && + islhs != isSuppressedLHSstr) { + continue; /* is a state var */ + } + if (islhs == isSuppressedLHS || + islhs == isSuppressedLHSstr){ sli++; - } else if (islhs == isLHS || islhs == isLhsStateExtra || islhs == isLHSparam){ + } else if (islhs == isLHS || + islhs == isLHSstr || + islhs == isLhsStateExtra || + islhs == isLHSparam || + islhs == isLHSstr){ li++; if (islhs == isLHSparam) pi++; } else { @@ -128,20 +140,12 @@ static inline void calcExtracmt(void) { } else { extraCmt=1; } - if (tb.hasDepotCmt){ + if (tb.hasDepotCmt == -1){ trans_syntax_error_report_fn0(_("'cmt(depot)' does not work with 'linCmt()'")); } - if (tb.hasCentralCmt) { + if (tb.hasCentralCmt == -1) { trans_syntax_error_report_fn0("'cmt(central)' does not work with 'linCmt()'"); } - } else { - if (tb.hasDepot && rx_syntax_require_ode_first){ - sPrint(&_bufw2, ODEFIRST, "depot"); - trans_syntax_error_report_fn0(_bufw2.s); - } else if (tb.hasCentral && rx_syntax_require_ode_first){ - sPrint(&_bufw2, ODEFIRST, "depot"); - trans_syntax_error_report_fn0(_bufw2.s); - } } } @@ -193,20 +197,95 @@ static inline SEXP calcIniVals(void) { return ini; } -static inline void populateStateVectors(SEXP state, SEXP sens, SEXP normState, int *stateRm, SEXP extraState) { +SEXP orderForderS1(SEXP ordIn); + +static inline int sortStateVectorsErrHandle(int prop, int pass, int i) { + if (prop == 0 || pass == 1) { + return 1; + } + if ((prop & prop0) != 0) { + sAppend(&sbt, "'%s(0)', ", tb.ss.line[tb.di[i]]); + } + if ((prop & propF) != 0) { + sAppend(&sbt, "'f(%s)', ", tb.ss.line[tb.di[i]]); + } + if ((prop & propAlag) != 0) { + sAppend(&sbt, "'alag(%s)', ", tb.ss.line[tb.di[i]]); + } + if ((prop & propRate) != 0) { + sAppend(&sbt, "'rate(%s)', ", tb.ss.line[tb.di[i]]); + } + if ((prop & propDur) != 0) { + sAppend(&sbt, "'dur(%s)', ", tb.ss.line[tb.di[i]]); + } + // Take off trailing "', + sbt.o -= 2; + sbt.s[sbt.o] = 0; + sAppend(&sbt, " present, but d/dt(%s) not defined\n", tb.ss.line[tb.di[i]]); + return 0; +} + +static inline SEXP sortStateVectors(SEXP ordS) { + int *ord = INTEGER(ordS); + for (int i = 0; i < Rf_length(ordS); i++) { + ord[i] = 0; // explicitly initialize to avoid valgrind warning + } + sbt.o = 0; // we can use sbt.o since all the code has already been output + sbt.s[0] = 0; + for (int i = 0; i < tb.de.n; i++) { + int cur = tb.didx[i]; + int prop = tb.dprop[i]; + int pass = 0; + if (tb.linCmt){ + if (tb.hasDepotCmt == 1 && !strcmp("depot", tb.ss.line[tb.di[i]])){ + pass = 1; + } else if ((tb.hasCentralCmt == 1 || tb.hasDepotCmt == 1) && + !strcmp("central", tb.ss.line[tb.di[i]])) { + pass = 1; + } + } + if (cur == 0) { + // This has a property without an ODE or cmt() statement; should error here. + if (sortStateVectorsErrHandle(prop, pass, i)) continue; + } else if (cur < 0) { + // This is a compartment only defined by CMT() and is used for + // dvid ordering, no properties should be defined. + ord[i] = -cur; + if (sortStateVectorsErrHandle(prop, pass, i)) continue; + } else { + ord[i] = cur; + } + } + if (sbt.o != 0) { + sbt.o--; // remove last newline + sbt.s[sbt.o] = 0; + sPrint(&_gbuf, "%s", sbt.s); + return R_NilValue; + } + return orderForderS1(ordS); +} + +static inline void populateStateVectors(SEXP state, SEXP sens, SEXP normState, int *stateRm, SEXP extraState, SEXP stateProp, SEXP sensProp, SEXP normProp, int *ordFp) { int k=0, j=0, m=0, p=0; char *buf; + int *statePropI = INTEGER(stateProp); + int *sensPropI = INTEGER(sensProp); + int *normPropI = INTEGER(normProp); for (int i=0; i1 && islhs != isLhsStateExtra && islhs != isLHSparam) { + if (islhs>1 && islhs != isLhsStateExtra && islhs != isLHSparam && + islhs != isLHSstr) { if (tb.lag[i] != 0){ buf=tb.ss.line[i]; if (islhs == isState){ @@ -263,9 +343,11 @@ static inline int assertStateCannotHaveDiff(int islhs, int i, char *buf) { } static inline int setLhsAndDualLhsParam(int islhs, SEXP lhs, SEXP params, char *buf, - int *li, int *pi) { - if (islhs == isLHS || islhs == isLhsStateExtra || islhs == isLHSparam) { + int *li, int *pi, SEXP lhsStr) { + if (islhs == isLHS || islhs == isLHSstr || + islhs == isLhsStateExtra || islhs == isLHSparam) { SET_STRING_ELT(lhs, li[0], mkChar(buf)); + INTEGER(lhsStr)[li[0]] = islhs == isLHSstr; li[0] = li[0]+1; if (islhs == isLHSparam) { if (!strcmp("CMT", buf)) { @@ -319,12 +401,12 @@ static inline void assertLhsAndDualLhsDiffNotLegal(int islhs, int i, char *buf) } } -static inline void populateParamsLhsSlhs(SEXP params, SEXP lhs, SEXP slhs, int *interp) { +static inline void populateParamsLhsSlhs(SEXP params, SEXP lhs, SEXP slhs, int *interp, SEXP lhsStr) { int li=0, pi=0, sli = 0; char *buf; for (int i=0; i +#include +#include +#include +#include + +static const char base36[37] = "0123456789abcdefghijklmnopqrstuvwxyz"; + +SEXP _rxode2_itostr(SEXP x, SEXP base) { + const R_len_t n = length(x); + const R_len_t b = INTEGER(base)[0]; + SEXP res = PROTECT(allocVector(STRSXP, n)); + + const R_len_t buflen = ceil(log(exp2(64) / log(b))); + char buffer[buflen + 1]; + buffer[buflen] = '\0'; + + for (R_len_t i = 0; i < n; i++) { + R_len_t offset = buflen; + int xi = INTEGER(x)[i]; + do { + buffer[--offset] = base36[xi % b]; + } while (xi /= b); + + SET_STRING_ELT(res, i, mkChar(&buffer[offset])); + } + + UNPROTECT(1); + return res; +} + +static const char base26[27] = "abcdefghijklmnopqrstuvwxyz"; + +SEXP _rxode2_itoletter(SEXP x, SEXP base) { + const R_len_t n = length(x); + const R_len_t b = INTEGER(base)[0]; + SEXP res = PROTECT(allocVector(STRSXP, n)); + + const R_len_t buflen = ceil(log(exp2(64) / log(b))); + char buffer[buflen + 1]; + buffer[buflen] = '\0'; + + for (R_len_t i = 0; i < n; i++) { + R_len_t offset = buflen; + int xi = INTEGER(x)[i]; + do { + buffer[--offset] = base26[xi % b]; + } while (xi /= b); + + SET_STRING_ELT(res, i, mkChar(&buffer[offset])); + } + + UNPROTECT(1); + return res; +} diff --git a/src/nearPD.cpp b/src/nearPD.cpp index d1245e6d2..67b881613 100644 --- a/src/nearPD.cpp +++ b/src/nearPD.cpp @@ -5,27 +5,26 @@ #define STRICT_R_HEADER #include #include "nearPD.h" +#include + +lotriNearPDarmaSetup using namespace arma; using namespace Rcpp; -Function getRxFn(std::string name); - bool rxNearPD(arma::mat &ret, const arma::mat in) { - Function mnearpd = getRxFn(".nearPD"); - RObject retRO = mnearpd(in); - if (Rf_isMatrix(retRO)) { - ret = as(retRO); + if (lotriNearPDarma(ret, in)) { return true; + } else { + ret = in; + return false; } - ret = in; - return false; + return false; // nocov } unsigned int rxNearPdChol(Rcpp::NumericMatrix &ret, Rcpp::NumericMatrix x, bool isChol) { arma::mat tmpM = as(x); arma::mat reta; - if (!x.hasAttribute("dimnames")) { return rxNearPdChol_not_named; } else if (isChol) { diff --git a/src/par_solve.cpp b/src/par_solve.cpp index 3cabb1914..ee98750e0 100644 --- a/src/par_solve.cpp +++ b/src/par_solve.cpp @@ -15,6 +15,10 @@ #include "../inst/include/rxode2parseGetTime.h" #define SORT gfx::timsort +extern "C" uint32_t getRxSeed1(int ncores); +extern "C" void setSeedEng1(uint32_t seed); +extern "C" void setRxSeedFinal(uint32_t seed); + extern "C" { #include "dop853.h" #include "common.h" @@ -442,14 +446,6 @@ t_calc_lhs calc_lhs = NULL; t_update_inis update_inis = NULL; -extern "C" t_calc_lhs getRxLhs() { - return calc_lhs; -} - -extern "C" t_update_inis getUpdateInis() { - return update_inis; -} - t_dydt_lsoda_dum dydt_lsoda_dum = NULL; t_dydt_liblsoda dydt_liblsoda = NULL; @@ -2153,14 +2149,17 @@ extern "C" void par_indLin(rx_solve *rx){ // It was buggy due to Rprint. Use REprint instead since Rprint calls the interrupt every so often.... int abort = 0; // FIXME parallel + uint32_t seed0 = getRxSeed1(1); for (int solveid = 0; solveid < nsim*nsub; solveid++){ if (abort == 0){ + setSeedEng1(seed0 + solveid - 1 ); ind_indLin(rx, solveid, update_inis, ME, IndF); if (displayProgress){ // Can only abort if it is long enough to display progress. curTick = par_progress(solveid, nsim*nsub, curTick, 1, t0, 0); } } } + setRxSeedFinal(seed0 + nsim*nsub); if (abort == 1){ op->abort = 1; /* yp0 = NULL; */ @@ -2296,10 +2295,6 @@ extern "C" void ind_liblsoda0(rx_solve *rx, rx_solving_options *op, struct lsoda ind->solveTime += ((double)(clock() - t0))/CLOCKS_PER_SEC; } -extern "C" uint32_t getRxSeed1(int ncores); -extern "C" void setSeedEng1(uint32_t seed); -extern "C" void setRxSeedFinal(uint32_t seed); - extern "C" void ind_liblsoda(rx_solve *rx, int solveid, t_dydt_liblsoda dydt, t_update_inis u_inis){ rx_solving_options *op = &op_global; @@ -2428,11 +2423,13 @@ extern "C" void par_liblsoda(rx_solve *rx){ // http://permalink.gmane.org/gmane.comp.lang.r.devel/27627 // It was buggy due to Rprint. Use REprint instead since Rprint calls the interrupt every so often.... int abort = 0; + uint32_t seed0 = getRxSeed1(cores); #ifdef _OPENMP #pragma omp parallel for num_threads(op->cores) #endif for (int solveid = 0; solveid < nsim*nsub; solveid++){ if (abort == 0){ + setSeedEng1(seed0 + rx->ordId[solveid] - 1); ind_liblsoda0(rx, op, opt, solveid, dydt_liblsoda, update_inis); if (displayProgress){ #pragma omp critical @@ -2449,6 +2446,7 @@ extern "C" void par_liblsoda(rx_solve *rx){ } } } + setRxSeedFinal(seed0 + nsim*nsub); if (abort == 1){ op->abort = 1; /* yp0 = NULL; */ @@ -2711,17 +2709,22 @@ extern "C" void par_lsoda(rx_solve *rx){ int curTick = 0; int abort = 0; + uint32_t seed0 = getRxSeed1(1); for (int solveid = 0; solveid < nsim*nsub; solveid++){ - ind_lsoda0(rx, &op_global, solveid, neq, rwork, lrw, iwork, liw, jt, - dydt_lsoda_dum, update_inis, jdum_lsoda); - if (displayProgress){ // Can only abort if it is long enough to display progress. - curTick = par_progress(solveid, nsim*nsub, curTick, 1, t0, 0); - if (checkInterrupt()){ - abort =1; - break; + if (abort == 0){ + setSeedEng1(seed0 + solveid - 1 ); + ind_lsoda0(rx, &op_global, solveid, neq, rwork, lrw, iwork, liw, jt, + dydt_lsoda_dum, update_inis, jdum_lsoda); + if (displayProgress){ // Can only abort if it is long enough to display progress. + curTick = par_progress(solveid, nsim*nsub, curTick, 1, t0, 0); + if (checkInterrupt()){ + abort =1; + break; + } } } } + setRxSeedFinal(seed0 + nsim*nsub); if (abort == 1){ op_global.abort = 1; } else { @@ -2938,8 +2941,10 @@ void par_dop(rx_solve *rx){ int curTick = 0; int abort = 0; + uint32_t seed0 = getRxSeed1(1); for (int solveid = 0; solveid < nsim*nsub; solveid++){ if (abort == 0){ + setSeedEng1(seed0 + solveid - 1 ); ind_dop0(rx, &op_global, solveid, neq, dydt, update_inis); if (displayProgress && abort == 0){ if (checkInterrupt()) abort =1; @@ -2947,6 +2952,7 @@ void par_dop(rx_solve *rx){ if (displayProgress) curTick = par_progress(solveid, nsim*nsub, curTick, 1, t0, 0); } } + setRxSeedFinal(seed0 + nsim*nsub); if (abort == 1){ op->abort = 1; } else { diff --git a/src/par_solve.h b/src/par_solve.h index 2a2ea6fb2..00e93ef90 100644 --- a/src/par_solve.h +++ b/src/par_solve.h @@ -40,7 +40,13 @@ extern "C" { } ind->inLhs = inLhs; if (rx->nMtime) calc_mtime(solveid, ind->mtime); - for (int j = op->nlhs; j--;) ind->lhs[j] = NA_REAL; + for (int j = op->nlhs; j--;) { + if (op->lhs_str[j] == 1) { + ind->lhs[j] = 1.0; // default is first string defined + } else { + ind->lhs[j] = NA_REAL; + } + } if ((inLhs == 0 && op->neq > 0) || (inLhs == 1 && op->neq == 0 && (rx->nIndSim > 0 || (rx->simflg & 1) != 0 ))) { ind->isIni = 1; diff --git a/src/parseAllowAssign.h b/src/parseAllowAssign.h new file mode 100644 index 000000000..ddf916f84 --- /dev/null +++ b/src/parseAllowAssign.h @@ -0,0 +1,11 @@ +static inline void parseAllowAssignOrState(const char *s) { + char *strings[] = {"cmt", "dvid", "addl", "ii", "ss", "amt", "dur", "rate", "Rprintf", "printf", "print"}; + for (int i=0; i<11; i++) { + if (!strcmp(strings[i], s)) { + sPrint(&_gbuf,"'%s' cannot be a state or lhs expression",s); + _rxode2parse_unprotect(); + err_trans(_gbuf.s); + return; + } + } +} diff --git a/src/parseAssignStr.h b/src/parseAssignStr.h new file mode 100644 index 000000000..57eeb80ba --- /dev/null +++ b/src/parseAssignStr.h @@ -0,0 +1,154 @@ +static inline int new_assign_str(const char *s) { + parseAllowAssignOrState(s); + for (int i=0; i tb.allocS){ + tb.allocS+=MXDER; + tb.si=R_Realloc(tb.si, tb.allocS, int); + tb.isi=R_Realloc(tb.isi, tb.allocS, int); + tb.sin=R_Realloc(tb.sin, tb.allocS, int); + } + return 1; +} + +static inline void add_assign_str(char *v) { + tb.id=tb.str.n; + tb.si[tb.str.n] = tb.ix; + tb.isi[tb.str.n] = 0; // variable is not ignored by default + tb.sin[tb.str.n] = 0; // No values added yet + addLine(&(tb.str),"%s",v); +} + + +static inline int get_str_assign_int(int val, const char *s) { + for (int i=0; i tb.allocSV){ + tb.allocSV+=MXDER; + tb.strValI=R_Realloc(tb.strValI, tb.allocSV, int); + tb.strValII=R_Realloc(tb.strValII, tb.allocSV, int); + } + int n = tb.sin[tb.id]; + n++; + tb.strValI[tb.strVal.n] = val; + tb.strValII[tb.strVal.n] = n; // R factors start with 1 instead of 0 + tb.sin[tb.id] = n; + addLine(&(tb.strVal),"%s", s); + return n; +} + +static inline void errorStrAssign(const char *v) { + new_assign_str(v); + int n = tb.sin[tb.id]; + if (n > 1) { + sPrint(&_gbuf,"the string variable '%s' can only be 1 to %d, or '",v, n); + } else { + sPrint(&_gbuf,"the string variable '%s' can only be 1 or '",v, n); + } + for (int i=0; istart_loc.s, xpn->end); + if (!new_de(v, 0)) { + add_de(ni, name, v, isCmtLhsStatement(ni, name, v), fromCMTprop); + sPrint(&_gbuf,"'%s' compartment cannot be a string variable", v); + updateSyntaxCol(); + trans_syntax_error_report_fn(_gbuf.s); + return 0; + } + new_or_ith(v); // update tb.ix for the right value + if (tb.lh[tb.ix]!= 0 && tb.lh[tb.ix] != isLHSstr && tb.lh[tb.ix] != isSuppressedLHSstr) { + sPrint(&_gbuf,"'%s' cannot be both a calculated and a string variable", v); + updateSyntaxCol(); + trans_syntax_error_report_fn(_gbuf.s); + return 0; + } + aProp(tb.ix); + aType(TASSIGN); + if (tb.lh[tb.ix] == 0 && tb.ini[tb.ix] == 0) { + tb.lh[tb.ix] = isLHSstr; + } else if (tb.lh[tb.ix] == isLHSstr || + tb.lh[tb.ix] == isSuppressedLHSstr) { + } else { + sPrint(&_gbuf,"'%s' needs to be first declared as a string by assignment or labels()", v); + updateSyntaxCol(); + trans_syntax_error_report_fn(_gbuf.s); + } + if (new_assign_str(v)){ + add_assign_str(v); + } + return 1; + } else if (i == 1) { + // variable type + char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + if (v[0] == '~') { + tb.isi[tb.id] = 1; // variable ignored + tb.lh[tb.ix] = isSuppressedLHSstr; + } + return 1; + } else if (i == 2) { + // actual string + sb.o =0; sbDt.o =0; sbt.o =0; + sAppend(&sb, "%s = ", tb.str.line[tb.id]); + sAppend(&sbDt, "%s = ", tb.str.line[tb.id]); + sAppend(&sbt, "%s ", tb.str.line[tb.id]); + if (tb.isi[tb.id]) { + // ignored variable + sAppendN(&sbt, "~", 1); + } else { + // output variable + sAppendN(&sbt, "<-", 2); + } + char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + sAppend(&sbt,"%s;", v); + // take out quotes + v++; + v[strlen(v)-1]=0; + int n = get_str_assign_int(tb.id, v); + sAppend(&sb, "%d; /* = '%s' */", n, v); + sAppend(&sbDt, "%d; /* = '%s' */ ", n, v); + char *buf = tb.str.line[tb.id]; + //addSymbolStr(buf); + if (tb.isi[tb.id]) { + // ignored + tb.lh[tb.ix] = isSuppressedLHSstr; + } else { + // not ignored + tb.lh[tb.ix] = isLHSstr; + } + return 1; + } + } + return 0; +} + +static inline int finalizeLineStrAssign(nodeInfo ni, char *name) { + if (nodeHas(assign_str)){ + addLine(&sbPm, "%s\n", sb.s); + addLine(&sbPmDt, "%s\n", sbDt.s); + sAppend(&sbNrm, "%s\n", sbt.s); + addLine(&sbNrmL, "%s\n", sbt.s); + ENDLINE; + return 1; + } + return 0; +} diff --git a/src/parseCmtProperties.h b/src/parseCmtProperties.h index 661bc24d3..8532af61a 100644 --- a/src/parseCmtProperties.h +++ b/src/parseCmtProperties.h @@ -1,8 +1,11 @@ static inline int handleCmtPropertyFbio(nodeInfo ni, char *name, char *v) { if (nodeHas(fbio)){ sb.o=0;sbDt.o=0; sbt.o=0; - sAppend(&sb, "_f[%d] = ", tb.id); - sAppend(&sbDt, "_f[%d] = ", tb.id); + if ((tb.dprop[tb.id] & propF) == 0) { + tb.dprop[tb.id] += propF; + } + sAppend(&sb, "_f[__DDT%d__] = ", tb.id); + sAppend(&sbDt, "_f[__DDT%d__] = ", tb.id); sAppend(&sbt, "f(%s)=", v); tb.curPropN=tb.id; if (foundF == 0) needSort+=1;// & 1 when F @@ -16,8 +19,11 @@ static inline int handleCmtPropertyFbio(nodeInfo ni, char *name, char *v) { static inline int handleCmtPropertyAlag(nodeInfo ni, char *name, char *v) { if (nodeHas(alag)){ sb.o=0;sbDt.o=0; sbt.o=0; - sAppend(&sb, "_alag[%d] = ", tb.id); - sAppend(&sbDt, "_alag[%d] = ", tb.id); + if ((tb.dprop[tb.id] & propAlag) == 0) { + tb.dprop[tb.id] += propAlag; + } + sAppend(&sb, "_alag[__DDT%d__] = ", tb.id); + sAppend(&sbDt, "_alag[__DDT%d__] = ", tb.id); sAppend(&sbt, "alag(%s)=", v); tb.curPropN=tb.id; if (foundLag == 0) needSort+=2; // & 2 when alag @@ -42,9 +48,12 @@ static inline int handleCmtPropertyAlag(nodeInfo ni, char *name, char *v) { static inline int handleCmtPropertyDur(nodeInfo ni, char *name, char *v) { if (nodeHas(dur)) { + if ((tb.dprop[tb.id] & propDur) == 0) { + tb.dprop[tb.id] += propDur; + } sb.o=0;sbDt.o=0; sbt.o=0; - sAppend(&sb, "_dur[%d] = ", tb.id); - sAppend(&sbDt, "_dur[%d] = ", tb.id); + sAppend(&sb, "_dur[__DDT%d__] = ", tb.id); + sAppend(&sbDt, "_dur[__DDT%d__] = ", tb.id); sAppend(&sbt, "dur(%s)=", v); tb.curPropN=tb.id; if (foundDur == 0) needSort+=4;// & 4 when dur @@ -58,8 +67,11 @@ static inline int handleCmtPropertyDur(nodeInfo ni, char *name, char *v) { static inline int handleCmtPropertyRate(nodeInfo ni, char *name, char *v) { if (nodeHas(rate)){ sb.o=0;sbDt.o=0; sbt.o=0; - sAppend(&sb, "_rate[%d] = ", tb.id); - sAppend(&sbDt, "_rate[%d] = ", tb.id); + if ((tb.dprop[tb.id] & propRate) == 0) { + tb.dprop[tb.id] += propRate; + } + sAppend(&sb, "_rate[__DDT%d__] = ", tb.id); + sAppend(&sbDt, "_rate[__DDT%d__] = ", tb.id); sAppend(&sbt, "rate(%s)=", v); tb.curPropN=tb.id; if (foundRate == 0) needSort+=8;// & 8 when rate @@ -71,24 +83,27 @@ static inline int handleCmtPropertyRate(nodeInfo ni, char *name, char *v) { } static inline int handleCmtPropertyCmtOrder(nodeInfo ni, char *name, char *v) { - if (nodeHas(cmt_statement)){ - sb.o=0;sbDt.o=0; sbt.o=0; - sAppend(&sbt, "cmt(%s)", v); - sAppend(&sbNrm, "%s;\n", sbt.s); - addLine(&sbNrmL, "%s;\n", sbt.s); + if (nodeHas(cmt_statement)) { + sb.o=0; sbDt.o=0; sbt.o=0; + //sAppend(&sbt, "cmt(%s)", v); + sAppend(&sbNrm, "cmt(%s);\n", v); + addLine(&sbNrmL, "cmt(%s);\n", v); return 1; } return 0; } static inline int handleCmtProperty(nodeInfo ni, char *name, int i, D_ParseNode *xpn) { + int isCmt = 0; if ((nodeHas(fbio) || nodeHas(alag) || nodeHas(dur) || nodeHas(rate) || - nodeHas(cmt_statement)) && i==2) { + (isCmt = nodeHas(cmt_statement))) && + i==2) { char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); int hasLhs=isCmtLhsStatement(ni, name, v); - if (new_de(v)){ - add_de(ni, name, v, hasLhs, fromCMTprop); + int from = isCmt ? fromCMT : fromCMTprop; + if (new_de(v, from)){ + add_de(ni, name, v, hasLhs, from); aProp(tb.de.n); handleCmtPropertyCmtOrder(ni, name, v); } else { @@ -112,8 +127,8 @@ static inline int handleRemainingAssignmentsIniProp(nodeInfo ni, char *name, int /* aAppendN("(__0__)", 7); */ aType(TINI); doDot2(&sb, &sbDt, v); - if (nodeHas(ini) && !new_de(v)){ - if (tb.idu[tb.id] == 0){ + if (nodeHas(ini) && !new_de(v, fromCMTprop)) { + if (tb.idu[tb.id] == 0) { new_or_ith(v); if (tb.lh[tb.ix] == isSuppressedLHS || tb.lh[tb.ix] == 29){ tb.lh[tb.ix] = 29; @@ -134,14 +149,14 @@ static inline int handleRemainingAssignmentsIniProp(nodeInfo ni, char *name, int static inline void handleRemainingAssignmentsRestProp(nodeInfo ni, char *name, int i, D_ParseNode *pn, D_ParseNode *xpn, char *v) { sb.o = 0; sbDt.o = 0; doDot2(&sb, &sbDt, v); - if (!new_de(v)){ + if (!new_de(v, fromCMTprop)) { if (tb.idu[tb.id] == 0){ // Change to 19 for LHS w/stateExtra new_or_ith(v); if (tb.lh[tb.ix] == isSuppressedLHS || tb.lh[tb.ix] == 29){ - tb.lh[tb.ix] = 29; + tb.lh[tb.ix] = 29; } else { - tb.lh[tb.ix] = isLhsStateExtra; + tb.lh[tb.ix] = isLhsStateExtra; } } else { sPrint(&_gbuf,"Cannot assign state variable %s; For initial condition assigment use '%s(0) ='",v,v); @@ -162,12 +177,12 @@ static inline int handleRemainingAssignmentsCalcPropMtime(nodeInfo ni, char *nam } -static inline int handleRemainingAssignmentsCalcPropComplexAssign(nodeInfo ni, char *name, char *v) { +static inline int handleRemainingAssignmentsCalcPropComplexAssign(nodeInfo ni, char *name, D_ParseNode *pn, char *v) { if (nodeHas(assignment) || (!rx_syntax_allow_ini && nodeHas(ini))) { if (tb.ix+1 == NV && tb.NEnd != NV){ // New assignment tb.ixL = tb.ix; - tb.lh[tb.ix] = isLHS; + tb.lh[tb.ix] = isLHS; } else if (tb.ix < 0){ if (!strcmp("rxlin___", v)) { tb.ixL=-1; @@ -177,7 +192,27 @@ static inline int handleRemainingAssignmentsCalcPropComplexAssign(nodeInfo ni, c trans_syntax_error_report_fn(_gbuf.s); } } else { - if (tb.lh[tb.ix] == notLHS){ + if (tb.lh[tb.ix] == isLHSstr || + tb.lh[tb.ix] == isSuppressedLHSstr) { + D_ParseNode *xpn = d_get_child(pn, 2); + const char* v2 = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + double d = 0.0; + int nd = sscanf(v2, "%lf", &d); + if (nd == 1) { + if (v2[0] == '-') return 1; + if (round(d) != d) { + errorStrAssign(v); + return 0; + } else { + new_assign_str(v); + int cur = round(d); + if (cur < 1 || cur > tb.sin[tb.id]) { + errorStrAssign(v); + return 0; + } + } + } + } else if (tb.lh[tb.ix] == notLHS){ tb.lh[tb.ix] = isLHSparam; } else { tb.lh[tb.ix] = isLHS; @@ -200,12 +235,43 @@ static inline int handleRemainingAssignmentsCalcPropIni(nodeInfo ni, char *name, if (nodeHas(ini) || nodeHas(ini0)) { D_ParseNode *xpn; double d; - if (tb.ini[tb.ix] == 0){ + if (tb.lh[tb.ix] == isLHSstr || + tb.lh[tb.ix] == isSuppressedLHSstr) { + if (nodeHas(ini0)) { + sPrint(&_gbuf,"cannot have initial conditions for string variable '%s'",v); + updateSyntaxCol(); + trans_syntax_error_report_fn(_gbuf.s); + return 0; + } else { + xpn = d_get_child(pn, 2); + /* Free(v); */ + const char* v2 = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + sscanf(v2, "%lf", &d); + if (round(d) != d) { + errorStrAssign(v); + return 0; + } else { + new_assign_str(v); // get the tb.id + int cur = round(d); + if (cur < 1 || cur > tb.sin[tb.id]) { + errorStrAssign(v); + return 0; + } + } + } + return 1; + } else if (tb.ini[tb.ix] == 0) { // If there is only one initialzation call, then assume // this is a parameter with an initial value. tb.ini[tb.ix] = 1; if (nodeHas(ini0)){ tb.ini0[tb.ix] = 1; + if (new_de(v, fromCMTprop)) { + add_de(ni, name, v, 0, fromCMTprop); + } + if ((tb.dprop[tb.id] & prop0) == 0) { + tb.dprop[tb.id] += prop0; + } xpn = d_get_child(pn, 3); /* Free(v); */ v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); @@ -259,12 +325,13 @@ static inline int handleRemainingAssignmentsCalcProps(nodeInfo ni, char *name, i new_or_ith(v); aProp(tb.ix); if (!(handleRemainingAssignmentsCalcPropMtime(ni, name) || - handleRemainingAssignmentsCalcPropComplexAssign(ni, name, v))) { + handleRemainingAssignmentsCalcPropComplexAssign(ni, name, pn, v))) { return handleRemainingAssignmentsCalcPropIni(ni, name, pn, v); } return 0; } + static inline int finalizeLineParam(nodeInfo ni, char *name) { if (nodeHas(param_statement)) { sbDt.o = 0; sbt.o = 0; diff --git a/src/parseDdt.h b/src/parseDdt.h index fa06c4007..5fd6d1adb 100644 --- a/src/parseDdt.h +++ b/src/parseDdt.h @@ -1,58 +1,36 @@ -static inline int new_de(const char *s) { +static inline int new_de(const char *s, int fromWhere) { int i; - if (!strcmp("cmt", s)) { - _rxode2parse_unprotect(); - err_trans("'cmt' cannot be a state or lhs expression"); - } - if (!strcmp("dvid", s)) { - _rxode2parse_unprotect(); - err_trans("'dvid' cannot be a state or lhs expression"); - } - if (!strcmp("addl", s)) { - _rxode2parse_unprotect(); - err_trans("'addl' cannot be a state or lhs expression"); - } - if (!strcmp("ii", s)) { - _rxode2parse_unprotect(); - err_trans("'ii' cannot be a state or lhs expression"); - } - if (!strcmp("ss", s)){ - _rxode2parse_unprotect(); - err_trans("'ss' cannot be a state or lhs expression"); - } - if (!strcmp("amt", s)) { - _rxode2parse_unprotect(); - err_trans("'amt' cannot be a state or lhs expression"); - } - if (!strcmp("dur", s)) { - _rxode2parse_unprotect(); - err_trans("'dur' cannot be a state or lhs expression"); - } - if (!strcmp("rate", s)) { - _rxode2parse_unprotect(); - err_trans("'rate' cannot be a state or lhs expression"); - } - if (!strcmp("Rprintf", s)) { - _rxode2parse_unprotect(); - err_trans("'Rprintf' cannot be a state"); - } - if (!strcmp("printf", s)){ - _rxode2parse_unprotect(); - err_trans("'printf' cannot be a state"); - } - if (!strcmp("print", s)) { - _rxode2parse_unprotect(); - err_trans("'print' cannot be a state"); - } + parseAllowAssignOrState(s); for (i=0; i tb.allocD){ tb.allocD+=MXDER; tb.di=R_Realloc(tb.di, tb.allocD, int); + tb.didx = R_Realloc(tb.didx, tb.allocD, int); + tb.dprop = R_Realloc(tb.dprop, tb.allocD, int); tb.idi=R_Realloc(tb.idi, tb.allocD, int); tb.idu=R_Realloc(tb.idu, tb.allocD, int); tb.dvid=R_Realloc(tb.dvid, tb.allocD, int); @@ -68,11 +46,15 @@ static inline int isCmtLhsStatement(nodeInfo ni, char *name, char *v) { hasLhs=1; tb.ini[tb.ix]=2; } - if (!strcmp("depot", v)){ - tb.hasDepotCmt = 1; - } else if (!strcmp("central", v)){ - tb.hasCentralCmt = 1; + if (tb.hasDepotCmt != -1 && !strcmp("depot", v)){ + tb.hasDepotCmt = -1; + } else if (tb.hasCentralCmt != -1 && !strcmp("central", v)){ + tb.hasCentralCmt = -1; } + } else if (tb.hasDepotCmt == 0 && !strcmp("depot", v)){ + tb.hasDepotCmt = 1; + } else if (tb.hasCentralCmt == 0 && !strcmp("central", v)){ + tb.hasCentralCmt = 1; } return hasLhs; } @@ -91,9 +73,6 @@ static inline int add_deCmtProp(nodeInfo ni, char *name, char *v, int hasLhs, in } static inline int add_deState(nodeInfo ni, char *name, char *v, int hasLhs, int fromWhere) { - if (fromWhere == fromDDT && strncmp(v, "rx__sens_", 3) == 0) { - tb.sensi++; - } new_or_ith(v); if (((tb.ini[tb.ix] == 1 && tb.ini0[tb.ix] == 0) || (tb.lh[tb.ix] == isLHS || tb.lh[tb.ix] == isLHSparam))){ @@ -109,29 +88,45 @@ static inline void add_de(nodeInfo ni, char *name, char *v, int hasLhs, int from tb.statei++; tb.id=tb.de.n; if (fromWhere == fromCMTprop && !nodeHas(cmt_statement)) { - if (rx_syntax_require_ode_first) { - if (!strcmp("depot", v)) { - tb.hasDepot = 1; - } else if (!strcmp("central", v)) { - tb.hasCentral = 1; - } else { - updateSyntaxCol(); - sPrint(&_gbuf,ODEFIRST,v); - trans_syntax_error_report_fn(_gbuf.s); - } + if (!new_assign_str(v)) { + updateSyntaxCol(); + sPrint(&_gbuf,"'%s' was already declared as a string variable",v); + trans_syntax_error_report_fn(_gbuf.s); } } int tmp = add_deCmtProp(ni, name, v, hasLhs, fromWhere) || add_deState(ni, name, v, hasLhs, fromWhere); (void) tmp; tb.di[tb.de.n] = tb.ix; + // Since cmt() can add fake compartments for dvids, distinguish + // between them in the location indicator + if (fromWhere == fromDDT) { + // if added from d/dt() count it as the next compartment + tb.didx[tb.de.n] = tb.didxn; + tb.didxn++; + if (strncmp(v, "rx__sens_", 9) == 0) { + tb.sensi++; + } + } else if (fromWhere == fromCMT) { + // if added from cmt() count it as the next compartment + tb.didx[tb.de.n] = -tb.didxn; + tb.didxn++; + } addLine(&(tb.de),"%s",v); } static inline int handleDdtAssign(nodeInfo ni, char *name, int i, D_ParseNode *pn, D_ParseNode *xpn) { if (nodeHas(derivative) && i==2) { char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); - if (new_de(v)) { + if (!new_or_ith(v)) { + if (tb.lh[tb.ix] == isSuppressedLHSstr || + tb.lh[tb.ix] == isLHSstr) { + updateSyntaxCol(); + sPrint(&_gbuf,"'%s' cannot be a derivative and string variable", v); + trans_syntax_error_report_fn(_gbuf.s); + } + } + if (new_de(v, fromDDT)) { add_de(ni, name, v, 0, fromDDT); } new_or_ith(v); @@ -139,11 +134,11 @@ static inline int handleDdtAssign(nodeInfo ni, char *name, int i, D_ParseNode *p /* printf("de[%d]->%s[%d]\n",tb.id,v,tb.ix); */ sb.o =0; sbDt.o =0; if (tb.idu[tb.id] == 0){ - sAppend(&sb, "__DDtStateVar__[%d] = ((double)(_ON[%d]))*(_IR[%d] ", tb.id, tb.id, tb.id); - sAppend(&sbDt, "__DDtStateVar_%d__ = ((double)(_ON[%d]))*(_IR[%d] ", tb.id, tb.id, tb.id); + sAppend(&sb, "__DDtStateVar__[__DDT%d__] = ((double)(_ON[__DDT%d__]))*(_IR[__DDT%d__] ", tb.id, tb.id, tb.id); + sAppend(&sbDt, "__DDtStateVar_%d__ = ((double)(_ON[__DDT%d__]))*(_IR[__DDT%d__] ", tb.id, tb.id, tb.id); } else { - sAppend(&sb, "__DDtStateVar__[%d] = ((double)(_ON[%d]))*(", tb.id, tb.id); - sAppend(&sbDt, "__DDtStateVar_%d__ = ((double)(_ON[%d]))*(", tb.id, tb.id); + sAppend(&sb, "__DDtStateVar__[__DDT%d__] = ((double)(_ON[__DDT%d__]))*(", tb.id, tb.id); + sAppend(&sbDt, "__DDtStateVar_%d__ = ((double)(_ON[__DDT%d__]))*(", tb.id, tb.id); } tb.idu[tb.id]=1; aType(TDDT); @@ -208,7 +203,7 @@ static inline int handleDdtRhs(nodeInfo ni, char *name, D_ParseNode *xpn) { { updateSyntaxCol(); char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); - if (new_de(v)){ + if (new_de(v, 0)){ /* sPrint(&buf2,"d/dt(%s)",v); */ updateSyntaxCol(); sPrint(&_gbuf,"Tried to use d/dt(%s) before it was defined",v); @@ -219,7 +214,7 @@ static inline int handleDdtRhs(nodeInfo ni, char *name, D_ParseNode *xpn) { sAppend(&sb, "__DDtStateVar_%d__", tb.id); sAppend(&sbDt, "__DDtStateVar_%d__", tb.id); } else { - sAppend(&sb, "__DDtStateVar__[%d]", tb.id); + sAppend(&sb, "__DDtStateVar__[__DDT%d__]", tb.id); sAppend(&sbDt, "__DDtStateVar_%d__", tb.id); aType(TDDT); } diff --git a/src/parseDfdy.h b/src/parseDfdy.h index 67e25ca8c..0536f357a 100644 --- a/src/parseDfdy.h +++ b/src/parseDfdy.h @@ -28,12 +28,12 @@ static inline int handleRhsDf(nodeInfo ni, char *name, int i, D_ParseNode *xpn, aType(TJAC); sAppend(&sbDt, "__PDStateVar_%s_SeP_",v); sAppend(&sbt,"df(%s)/dy(",v); - if (new_de(v)){ - updateSyntaxCol(); - sPrint(&_gbuf,_("d/dt(%s) needs to be defined before using a Jacobians for this state"),v); - trans_syntax_error_report_fn(_gbuf.s); + if (new_de(v, 0)) { + updateSyntaxCol(); + sPrint(&_gbuf,_("d/dt(%s) needs to be defined before using a Jacobians for this state"),v); + trans_syntax_error_report_fn(_gbuf.s); } else { - sAppend(&sb, "__PDStateVar__[%d*(__NROWPD__)+",tb.id); + sAppend(&sb, "__PDStateVar__[%d*(__NROWPD__)+",tb.id); } } } @@ -53,7 +53,7 @@ static inline int handleLhsDf(nodeInfo ni, char *name, int i, D_ParseNode *xpn, sbt.o = 0; sAppend(&sbDt,"__PDStateVar_%s_SeP_",v); sAppend(&sbt,"df(%s)/dy(",v); - if (new_de(v)){ + if (new_de(v, 0)){ updateSyntaxCol(); sPrint(&_gbuf,_("d/dt(%s) needs to be defined before using a Jacobians for this state"),v); trans_syntax_error_report_fn(_gbuf.s); @@ -89,7 +89,7 @@ static inline void handleDyThetaEta(nodeInfo ni, char *name, int i, D_ParseNode sAppend(&sbt, "%s)",v); new_or_ith(v); if (tb.lh[tb.ix] == isState){ - new_de(v); + new_de(v, 0); sAppend(&sb, "%d]",tb.id); } else { sAppendN(&sb, "0]",2); @@ -107,22 +107,22 @@ static inline int handleDy(nodeInfo ni, char *name, int i, D_ParseNode *xpn, int aAppendN(" = ", 3); sAppendN(&sbt ,"=", 1); if (*ii == 1){ - new_or_ith(_gbuf.s); + new_or_ith(_gbuf.s); } else { - new_or_ith(v); + new_or_ith(v); } *found = -1; for (*ii = 0; *ii < tb.ndfdy; (*ii)++){ - if (tb.df[*ii] == tb.cdf && tb.dy[*ii] == tb.ix){ - *found = *ii; - break; - } + if (tb.df[*ii] == tb.cdf && tb.dy[*ii] == tb.ix){ + *found = *ii; + break; + } } if (*found < 0){ - tb.df[tb.ndfdy] = tb.cdf; - tb.dy[tb.ndfdy] = tb.ix; - tb.ndfdy = tb.ndfdy+1; - tb.cdf = -1; + tb.df[tb.ndfdy] = tb.cdf; + tb.dy[tb.ndfdy] = tb.ix; + tb.ndfdy = tb.ndfdy+1; + tb.cdf = -1; } } return 1; diff --git a/src/parseFuns.h b/src/parseFuns.h index d08c267cf..c3b36afcd 100644 --- a/src/parseFuns.h +++ b/src/parseFuns.h @@ -158,11 +158,10 @@ static inline int handleFunctionLogit(transFunctions *tf) { D_ParseNode *xpn = d_get_child(tf->pn, 2); char *v2 = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); if (allSpaces(v2)){ - updateSyntaxCol(); - sPrint(&_gbuf, _("'%s' takes 1-3 arguments '%s(x,low,high)'"), - tf->v, tf->v); - /* Free(v2); */ - trans_syntax_error_report_fn(_gbuf.s); + updateSyntaxCol(); + sPrint(&_gbuf, _("'%s' takes 1-3 arguments '%s(x,low,high)'"), + tf->v, tf->v); + trans_syntax_error_report_fn(_gbuf.s); } /* Free(v2); */ sAppend(&sb, "_%s1(", tf->v); @@ -194,16 +193,16 @@ static inline int handleFunctionSum(transFunctions *tf) { !strcmp("max", tf->v) || !strcmp("min", tf->v) || !strcmp("rxord", tf->v)) { int ii = d_get_number_of_children(d_get_child(tf->pn,3))+1; - if (!strcmp("prod", tf->v)){ + if (!strcmp("prod", tf->v)) { sAppend(&sb, "_prod(_p, _input, _solveData->prodType, %d, (double) ", ii); sAppend(&sbDt, "_prod(_p, _input, _solveData->prodType, %d, (double) ", ii); if (maxSumProdN < ii){ maxSumProdN = ii; } - } else if (!strcmp("sum", tf->v)){ + } else if (!strcmp("sum", tf->v)) { sAppend(&sb, "_sum(_p, _pld, -__MAX_PROD__, _solveData->sumType, %d, (double) ", ii); sAppend(&sbDt, "_sum(_p, _pld, -__MAX_PROD__, _solveData->sumType, %d, (double) ", ii); - if (SumProdLD < ii){ + if (SumProdLD < ii) { SumProdLD = ii; } } else if (!strcmp("rxord", tf->v)) { @@ -334,6 +333,12 @@ static inline int handleBadFunctions(transFunctions *tf) { } if (foundFun == 0){ int ii = d_get_number_of_children(d_get_child(tf->pn,3))+1; + if (ii == 1) { + D_ParseNode *xpn = d_get_child(tf->pn, 2); + char *v2 = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + int allSpace=allSpaces(v2); + if (allSpace) ii = 0; + } SEXP lst = PROTECT(rxode2_getUdf2(tf->v, ii)); int udf = INTEGER(VECTOR_ELT(lst, 0))[0]; const char *udfInfo = R_CHAR(STRING_ELT(VECTOR_ELT(lst, 1), 0)); @@ -343,7 +348,15 @@ static inline int handleBadFunctions(transFunctions *tf) { updateSyntaxCol(); trans_syntax_error_report_fn(_gbuf.s); } else { - if (udf != ii) { + if (udf == -42) { + sAppend(&sb, "_udf(\".rxUiUdfNone\", (double *) NULL, -42, (double) ", ii); + sAppend(&sbDt, "_udf(\".rxUiUdfNone\",(double *) NULL, -42, (double) ", ii); + sAppend(&sbt, "%s(", tf->v); + tb.thread = notThreadSafe; + tf->i[0] = 1;// Parse next arguments + tf->depth[0]=1; + return 1; + } else if (udf != ii) { sPrint(&_gbuf, _("user function '%s' takes %d arguments, supplied %d"), tf->v, udf, ii); updateSyntaxCol(); diff --git a/src/parseFunsDosing.h b/src/parseFunsDosing.h index ee4d6d33a..118e14885 100644 --- a/src/parseFunsDosing.h +++ b/src/parseFunsDosing.h @@ -56,19 +56,13 @@ static inline int handleFunctionTadEmptyCcode(transFunctions *tf,char *v2) { static inline int handleFunctionTadSingleStateCcode(transFunctions *tf,char *v2) { sAppend(&sb, "_%s1(", tf->v); sAppend(&sbDt, "_%s1(", tf->v); - if (new_de(v2)){ + if (new_de(v2, 0)){ if (!strcmp("depot", v2)){ tb.hasDepot = 1; aAppendN("_DEPOT_)", 8); } else if (!strcmp("central", v2)){ tb.hasCentral = 1; aAppendN("_CENTRAL_)", 10); - } else if (rx_syntax_require_ode_first){ - updateSyntaxCol(); - sPrint(&_gbuf,ODEFIRST,v2); - trans_syntax_error_report_fn(_gbuf.s); - /* Free(v2); */ - /* Free(tf->v); */ } else { tb.statei++; sAppend(&sb, "%d)", tb.de.n); diff --git a/src/parseIdentifier.h b/src/parseIdentifier.h index e2aaf2607..f17fb866d 100644 --- a/src/parseIdentifier.h +++ b/src/parseIdentifier.h @@ -113,7 +113,7 @@ static inline void handleSafeZero(nodeInfo ni, char *name, int i, int *safe_zero char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); if (i == 0){ if (!strcmp("/",v)){ - aAppendN("safe_zero(", 10); + aAppendN("_div0(", 6); *safe_zero = 1; } else { *safe_zero = 0; diff --git a/src/parseLevels.h b/src/parseLevels.h new file mode 100644 index 000000000..740a39b46 --- /dev/null +++ b/src/parseLevels.h @@ -0,0 +1,125 @@ +static inline int handleLevelStr(nodeInfo ni, char *name, char *v) { + if (tb.lvlStr == 1 && nodeHas(string)) { + char *v2 = (char*)rc_dup_str(v, 0); + v2++; + v2[strlen(v2)-1]=0; // remove last quote + get_str_assign_int(tb.id, v2); + return 1; + } + return 0; +} + +static inline int handleLevelsStr(nodeInfo ni, char *name, int i, D_ParseNode *pn, D_ParseNode *xpn) { + if (nodeHas(levels_str)) { + if (i == 0 || i == 1 || i == 3 || i == 5 || i == 6) { + return 1; + } else if (i == 2) { + char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + new_or_ith(v); // update tb.ix for the right value + aProp(tb.ix); + aType(TNONE); + tb.lh[tb.ix] = isLHSstr; + if (new_assign_str(v)){ + add_assign_str(v); + } + return 1; + } else if (i == 4) { + // variable type + char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + if (v[0] == '~') { + tb.isi[tb.id] = 1; // variable ignored + tb.lh[tb.ix] = isSuppressedLHSstr; + } + tb.lvlStr = 1; + return 1; + } else if (i == 9) { + // clear code and add line + sbt.o = 0; + tb.lvlStr = 0; + tb.didEq=0; // reset the equation flag (to avoid double assign errors) + sAppend(&sbt, "levels(%s) ", tb.str.line[tb.id]); + if (tb.isi[tb.id]) { + // ignored variable + sAppendN(&sbt, "~ c(", 4); + } else { + // output variable + sAppendN(&sbt, "<- c(", 5); + } + for (int i=0; istart_loc.s, xpn->end); + new_or_ith(v); // update tb.ix for the right value + tb.lh[tb.ix] = isLHSstr; + if (new_assign_str(v)){ + add_assign_str(v); + } + aProp(tb.ix); + aType(TNONE); + return 1; + } else if (i == 4) { + // variable type + char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + if (v[0] == '~') { + tb.isi[tb.id] = 1; // variable ignored + tb.lh[tb.ix] = isSuppressedLHSstr; + } + return 1; + } else if (i == 5) { + // clear code and add line + sbt.o = 0; + char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + // take out quotes + v++; + v[strlen(v)-1]=0; + int n = get_str_assign_int(tb.id, v); + sAppend(&sbt, "levels(%s) ", tb.str.line[tb.id]); + if (tb.isi[tb.id]) { + // ignored variable + sAppendN(&sbt, "~ ", 2); + } else { + // output variable + sAppendN(&sbt, "<- ", 3); + } + sAppend(&sbt, "\"%s\";", v); + sb.o = sbDt.o = 0; + sAppend(&sb, "/* '%s' */", sbt.s); + sAppend(&sbDt, "/* '%s' */ ", sbt.s); + return 1; + } + return 1; + } + return 0; +} + + +static inline int finalizeLineLevelStr(nodeInfo ni, char *name) { + if (nodeHas(levels_str) || nodeHas(levels_str1)){ + addLine(&sbPm, "%s\n", sb.s); + addLine(&sbPmDt, "%s\n", sbDt.s); + sAppend(&sbNrm, "%s\n", sbt.s); + addLine(&sbNrmL, "%s\n", sbt.s); + ENDLINE; + return 1; + } + return 0; +} diff --git a/src/parseStatements.h b/src/parseStatements.h index b8cee7312..05b508ae6 100644 --- a/src/parseStatements.h +++ b/src/parseStatements.h @@ -63,11 +63,25 @@ static inline int handleDvidStatement(nodeInfo ni, char *name, D_ParseNode *xpn, } static inline int handleRemainingAssignments(nodeInfo ni, char *name, int i, D_ParseNode *pn, D_ParseNode *xpn) { - if (nodeHas(ini0f) && rx_syntax_allow_ini && i == 0){ + if (nodeHas(ini0f) && i == 0) { + char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); + if (new_de(v, fromCMTprop)) { + add_de(ni, name, v, isCmtLhsStatement(ni, name, v), fromCMTprop); + aProp(tb.de.n); + if ((tb.dprop[tb.id] & prop0) == 0) { + tb.dprop[tb.id] += prop0; + } + } + new_or_ith(v); + if (tb.lh[tb.ix] == isLHSstr || tb.lh[tb.ix] == isSuppressedLHSstr) { + sPrint(&_gbuf,"cannot have initial conditions for string variable '%s'",v); + updateSyntaxCol(); + trans_syntax_error_report_fn(_gbuf.s); + return 0; + } foundF0=1; aType(TF0); sb.o =0; sbDt.o=0; sbt.o = 0; - char *v = (char*)rc_dup_str(xpn->start_loc.s, xpn->end); doDot2(&sb, &sbDt, v); sAppend(&sbt, "%s(0)",v); } @@ -190,6 +204,9 @@ static inline void finalizeLine(nodeInfo ni, char *name, D_ParseNode *pn, int is finalizeLineParam(ni, name) || finalizeLineSelectionStatement(ni, name, isWhile) || finalizeLinePower(ni, name) || - finalizeLineInterp(ni, name); + finalizeLineInterp(ni, name) || + finalizeLineStrAssign(ni, name) || + finalizeLineLevelStr(ni, name) + ; (void) tmp; } diff --git a/src/rx2api.c b/src/rx2api.c new file mode 100644 index 000000000..c59d3f778 --- /dev/null +++ b/src/rx2api.c @@ -0,0 +1,196 @@ +#include "../inst/include/rxode2.h" +#include "rx2api.h" + +rx_solve *getRxSolve_(void); + +rx_solving_options* getSolvingOptions(rx_solve* rx) { + return rx->op; +} + +rx_solving_options_ind *getSolvingOptionsInd(rx_solve *rx, int id) { + int nall = rx->nsub*rx->nsim; + if (id < 0 || id >= nall) { + Rf_error("[getSolvingOptionsInd]: id (%d) should be between [0, %d); nsub: %d nsim: %d", id, nall, rx->nsub, rx->nsim); + } + return &(rx->subjects[id]); +} + +//////////////////////////////////////////////////////////////////////// +// Individual solving options +//////////////////////////////////////////////////////////////////////// + +double getIndLambda(rx_solving_options_ind* ind) { + return ind->lambda; +} + +int getIndLambdaYj(rx_solving_options_ind* ind) { + return (int)(ind->yj); +} + +double getIndLogitLow(rx_solving_options_ind* ind) { + return ind->logitLow; +} + +double getIndLogitHi(rx_solving_options_ind* ind) { + return ind->logitHi; +} + + +void setIndParPtr(rx_solving_options_ind* ind, int i, double val) { + rx_solve* rx = getRxSolve_(); + if (i < 0 || i >= rx->npars) { + Rf_error("[setIndParPtr]: i (%d) should be between [0, %d) when assigning %f", i, rx->npars, val); + } + ind->par_ptr[i] = val; +} + +double getIndParPtr(rx_solving_options_ind* ind, int i) { + rx_solve* rx = getRxSolve_(); + if (i < 0 || i >= rx->npars) { + Rf_error("[getIndParPtr]: i (%d) should be between [0, %d)", i, rx->npars); + } + return ind->par_ptr[i]; +} + +int getIndNallTimes(rx_solving_options_ind* ind) { + return ind->n_all_times; +} + +void setIndIdx(rx_solving_options_ind* ind, int j) { + ind->idx = j; +} + +int getIndIx(rx_solving_options_ind* ind, int j) { + if (j < 0 || j >= ind->n_all_times) { + Rf_error("[getIndIx]: j (%d) should be between [0, %d)", j, ind->n_all_times); + } + return ind->ix[j]; +} + +int getIndEvid(rx_solving_options_ind* ind, int kk) { + if (kk < 0 || kk >= ind->n_all_times) { + Rf_error("[getIndEvid]: kk (%d) should be between [0, %d)", kk, ind->n_all_times); + } + return ind->evid[kk]; +} + +double *getIndLhs(rx_solving_options_ind* ind) { + return ind->lhs; +} + +int getIndNdoses(rx_solving_options_ind* ind) { + return ind->ndoses; +} + +int getIndNevid2(rx_solving_options_ind* ind) { + return ind->nevid2; +} + +void setIndSolve(rx_solving_options_ind* ind, int solve) { + ind->solved = solve; +} + +double *getIndSolve(rx_solving_options_ind* ind) { + return ind->solve; +} + +double getIndDv(rx_solving_options_ind* ind, int j) { + if (j < 0 || j >= ind->n_all_times) { + Rf_error("[getIndDv]: j (%d) should be between [0, %d)", j, ind->n_all_times); + } + return ind->dv[j]; +} + +int getIndYj(rx_solving_options_ind* ind) { + return (int)(ind->yj); +} + +double getIndLimit(rx_solving_options_ind* ind, int kk) { + if (kk < 0 || kk >= ind->n_all_times) { + Rf_error("[getIndLimit]: kk (%d) should be between [0, %d)", kk, ind->n_all_times); + } + return ind->limit[kk]; +} + +int getIndCens(rx_solving_options_ind* ind, int kk) { + if (kk < 0 || kk >= ind->n_all_times) { + Rf_error("[getIndCens]: kk (%d) should be between [0, %d)", kk, ind->n_all_times); + } + return ind->cens[kk]; +} + +int getIndIdx(rx_solving_options_ind* ind) { + return ind->idx; +} + +//////////////////////////////////////////////////////////////////////// +// Solving options (rx->op) +//////////////////////////////////////////////////////////////////////// + +int getOpNeq(rx_solving_options* op) { + return op->neq; +} + +void setOpNeq(rx_solving_options* op, int neq) { + op->neq = neq; +} + +int hasOpBadSolve(rx_solving_options* op) { + return op->badSolve; +} + +int getOpNlin(rx_solving_options* op) { + return op->nlin; +} + +int getOpCores(rx_solving_options* op) { + return op->cores; +} + +int getOpNlhs(rx_solving_options* op) { + return op->nlhs; +} + +int getOpStiff(rx_solving_options* op) { + return op->stiff; +} + +void resetOpBadSolve(rx_solving_options* op) { + op->badSolve = 0; +} +//////////////////////////////////////////////////////////////////////// +// Solving options in rx +//////////////////////////////////////////////////////////////////////// + +int getRxNsub(rx_solve *rx) { + return rx->nsub; +} + +int hasRxLimit(rx_solve *rx) { + return rx->limit; +} + +int hasRxCens(rx_solve *rx) { + return rx->cens; +} + +int getRxNall(rx_solve *rx) { + return rx->nall; +} + +int getRxNobs(rx_solve *rx) { + return rx->nobs; +} + +int getRxNobs2(rx_solve *rx) { + return rx->nobs2; +} +//////////////////////////////////////////////////////////////////////// +// Get solve vector for ith solve +//////////////////////////////////////////////////////////////////////// +double * getOpIndSolve(rx_solving_options* op, rx_solving_options_ind* ind, int idx) { + if (idx < 0 || idx >= ind->n_all_times) { + Rf_error("[getOpIndSolve]: the individual should be between [0, %d); neq: %d nlin: %d", ind->n_all_times, op->neq, op->nlin); + } + return ind->solve + (op->neq + op->nlin)*(idx); +} diff --git a/src/rx2api.h b/src/rx2api.h new file mode 100644 index 000000000..4c131cf90 --- /dev/null +++ b/src/rx2api.h @@ -0,0 +1,128 @@ +#ifndef __RX2API_H__ +#define __RX2API_H__ +#if defined(__cplusplus) +extern "C" { +#endif + // rx2api.h + + // This function gets the global rx solving options + rx_solving_options* getSolvingOptions(rx_solve* rx); + + // This function gets the individual solving options for id + rx_solving_options_ind* getSolvingOptionsInd(rx_solve *rx, int id); + + // This gets the current transformation of both sides variables + + // First is the lambda from Cox-Box and Yeo-Johnson transformations + double getIndLambda(rx_solving_options_ind* ind); + + // this gets the transformation type + int getIndLambdaYj(rx_solving_options_ind* ind); + + // transformation high boundary + double getIndLogitLow(rx_solving_options_ind* ind); + + // transformation lower boundary + double getIndLogitHi(rx_solving_options_ind* ind); + + // Set individual parameters in the par_ptr double vector + void setIndParPtr(rx_solving_options_ind* ind, int i, double val); + + // Get individual parameters in the ptr_ptr double vector + double getIndParPtr(rx_solving_options_ind* ind, int i); + + // The the individual's number of time and dosing points + int getIndNallTimes(rx_solving_options_ind* ind); + + // Set the individual's index + void setIndIdx(rx_solving_options_ind* ind, int j); + + // Get the sorted index (ix) j for the individual + int getIndIx(rx_solving_options_ind* ind, int j); + + // Get the event id for the individual + int getIndEvid(rx_solving_options_ind* ind, int kk); + + // Get Individual Left Hand Side (LHS) vector + double *getIndLhs(rx_solving_options_ind* ind); + + // Get the number of doses for the individual + int getIndNdoses(rx_solving_options_ind* ind); + + // This gets the number of events with EVID=2 in the individual + int getIndNevid2(rx_solving_options_ind* ind); + + // This sets the index of where the linear compartment solver is solved to. + void setIndSolve(rx_solving_options_ind* ind, int solve); + + // This gets the double vector of the individual's solver + double *getIndSolve(rx_solving_options_ind* ind); + + // This gets the individual's dv at position j + double getIndDv(rx_solving_options_ind* ind, int j); + + // Gets the individual's transformation type at the current time-point. + int getIndYj(rx_solving_options_ind* ind); + + // Gets the individual's censoring limit at time index kk + double getIndLimit(rx_solving_options_ind* ind, int kk); + + // Get the individual's censoring flag should be (0, -1, -1) at time index kk + int getIndCens(rx_solving_options_ind* ind, int kk); + + // Get the index of the current solve + int getIndIdx(rx_solving_options_ind* ind); + + // Get the problems number of ode equatons + int getOpNeq(rx_solving_options* op); + + // Set the problems number of ode equations; This should be used + // with cation This is used in the inner problem to calculate the + // likelihood for finite differences. It corrupts the solving + // structure, so should be used with extreme caution. + void setOpNeq(rx_solving_options* op, int neq); + + // Does this problem have a bad solve? + int hasOpBadSolve(rx_solving_options* op); + + // Get the number of linear-related compartments + int getOpNlin(rx_solving_options* op); + + // Get the number of cores from the rxode2 solving options + int getOpCores(rx_solving_options* op); + + // Get the number of lhs in the rxode2 solving options + int getOpNlhs(rx_solving_options* op); + + // Get the solving method (historically called stiff) from the + // rxode2 solving options + int getOpStiff(rx_solving_options* op); + + // reset the bad solve flag (that way you can repeat with different + // options) + void resetOpBadSolve(rx_solving_options* op); + + // Get the number of subjects in the rx_solve structure + int getRxNsub(rx_solve *rx); + + // Get if the rxode2 has the limit (for censoring) + int hasRxLimit(rx_solve *rx); + + //Does the rxode2 problem have censoring column? + int hasRxCens(rx_solve *rx); + + // Get the number of all times in the rxode2 problem + int getRxNall(rx_solve *rx); + + // Get the number of observation sin the rxode2 problem + int getRxNobs(rx_solve *rx); + + // Get the number of observations excluding evid=2 + int getRxNobs2(rx_solve *rx); + + double * getOpIndSolve(rx_solving_options* op, rx_solving_options_ind* ind, int idx); + +#if defined(__cplusplus) +} +#endif +#endif // __RX2API_H__ diff --git a/src/rxData.cpp b/src/rxData.cpp index 7ed6e4aaf..01ff397fc 100644 --- a/src/rxData.cpp +++ b/src/rxData.cpp @@ -32,6 +32,7 @@ #include "../inst/include/rxode2parseVer.h" #include "../inst/include/rxode2random_fillVec.h" #include "rxomp.h" +#include "strncmp.h" #ifdef ENABLE_NLS #include #define _(String) dgettext ("rxode2", String) @@ -71,8 +72,6 @@ extern "C" SEXP _rxode2_udfEnvSet(SEXP udf); extern "C" SEXP _rxode2_udfReset(); extern "C" SEXP _rxode2_rxC(SEXP in); -extern "C" SEXP getForder(void); -extern "C" int useForder(void); #include "../inst/include/rxode2_as.h" @@ -737,8 +736,8 @@ List rxModelVars_rxode2(const RObject &obj){ //' //' @noRd List rxModelVars_blank() { - List ret(24); - CharacterVector retN(24); + List ret(30); + CharacterVector retN(30); ret[0] = CharacterVector::create(); // params retN[0] = "params"; ret[1] = CharacterVector::create(); // lhs @@ -804,11 +803,42 @@ List rxModelVars_blank() { ret[21] = interp; retN[21] = "interp"; - ret[22] = IntegerVector::create(0); // timeId - retN[22] = "timeId"; + List strAssign; + strAssign.attr("names") = CharacterVector::create(); + ret[22] = strAssign; // strAssign + retN[22] = "strAssign"; + + LogicalVector lhsStr = LogicalVector::create(); + lhsStr.attr("names") = CharacterVector::create(); + ret[23] = lhsStr; // md5 + retN[23] = "lhsStr"; + + IntegerVector stateProp = IntegerVector::create(); + stateProp.attr("names") = CharacterVector::create(); + ret[24] = stateProp; // stateProp + retN[24] = "stateProp"; + + IntegerVector sensProp = IntegerVector::create(); + sensProp.attr("names") = CharacterVector::create(); + ret[25] = sensProp; // sensProp + retN[25] = "sensProp"; + + IntegerVector normProp = IntegerVector::create(); + normProp.attr("names") = CharacterVector::create(); + ret[26] = normProp; // normProp + retN[26] = "normProp"; + + IntegerVector stateOrd = IntegerVector::create(); + normProp.attr("names") = CharacterVector::create(); + ret[27] = stateOrd; + retN[27] = "stateOrd"; + + ret[28] = IntegerVector::create(0); // timeId + retN[28] = "timeId"; + + ret[29] =CharacterVector::create(_["file_md5"] = "", _["parsed_md5"] = ""); // md5 + retN[29] = "md5"; - ret[23] =CharacterVector::create(_["file_md5"] = "", _["parsed_md5"] = ""); // md5 - retN[23] = "md5"; ret.attr("names") = retN; ret.attr("class") = "rxModelVars"; return ret; @@ -1440,6 +1470,7 @@ struct rx_globals { int *gidose; int *gpar_cov; int *gpar_covInterp; + int *glhs_str; int *gParPos; int *gParPos2; @@ -2704,10 +2735,51 @@ extern void resetFkeep() { } -extern "C" double get_fkeep(int col, int id, rx_solving_options_ind *ind) { +extern "C" double get_fkeep(int col, int id, rx_solving_options_ind *ind,int fid) { + // fid is the first index of the id for keep List keepFcovI= keepFcov.attr("keepCov"); int idx = keepFcovI[col]; - if (idx == 0) return REAL(keepFcov[col])[id]; + if (idx == 0) { + double *vals = REAL(keepFcov[col]); + double val = vals[id]; + if (R_IsNA(val) || R_IsNaN(val)) { + rx_solve* rx = getRxSolve_(); + rx_solving_options* op = rx->op; + if (op->keep_interp == 1) { // locf + int i = id; + // find the previous non-NA value + while (i >= fid && (R_IsNA(vals[i]) || R_IsNaN(vals[i]))) { + i--; + } + // if it can't be found find the next non-NA value + if (R_IsNA(vals[i]) || R_IsNaN(vals[i])) { + i = id; + while (i < fid + ind->n_all_times && (R_IsNA(vals[i]) || R_IsNaN(vals[i]))) { + i++; + } + } + return vals[i]; + } else if (op->keep_interp == 0) { // nocb + int i = id; + // find the next non-NA value + while (i < fid + ind->n_all_times && (R_IsNA(vals[i]) || R_IsNaN(vals[i]))) { + i++; + } + // if it can't be found find the previous non-NA value + if (R_IsNA(vals[i]) || R_IsNaN(vals[i])) { + i = id; + while (i >= fid && (R_IsNA(vals[i]) || R_IsNaN(vals[i]))) { + i--; + } + } + return vals[i]; + } else { // should be op->keep_interp == 2 + // this will return NA + return val; + } + } + return val; + } return ind->par_ptr[idx-1]; } @@ -2738,6 +2810,9 @@ extern "C" SEXP get_fkeepChar(int col, double val) { List cur = keepFcovType[col]; StringVector levels = cur[1]; int i = (int)(val - 1.0); + if (R_IsNA(val) || R_IsNaN(val)) { + return NA_STRING; + } return wrap(levels[i]); } @@ -2763,15 +2838,8 @@ extern "C" void sortIds(rx_solve* rx, int ini) { ind = &(rx->subjects[i]); solveTime[i] = ind->solveTime; } - Function order = as(getForder()); - if (useForder()) { - ord = order(solveTime, _["na.last"] = LogicalVector::create(NA_LOGICAL), - _["decreasing"] = LogicalVector::create(true)); - } else { - ord = order(solveTime, _["na.last"] = LogicalVector::create(NA_LOGICAL), - _["method"]="radix", - _["decreasing"] = LogicalVector::create(true)); - } + Function order1 = getRxFn(".order1"); // decreasing + ord = order1(solveTime, _["decreasing"] = LogicalVector::create(true)); // This assumes that this has already been created std::copy(ord.begin(), ord.end(), rx->ordId); } @@ -2806,7 +2874,6 @@ struct rxSolve_t { int parType = 1; int nPopPar = 1; CharacterVector nmP; - int npars; NumericVector mvIni; int nsvar; bool idFactor; @@ -3540,8 +3607,9 @@ static inline void rxSolve_datSetupHmax(const RObject &obj, const List &rxContro int dfN = dfNames.size(); IntegerVector evid = as(dataf[rxcEvid]); IntegerVector si = as(rxSolveDat->mv[RxMv_state_ignore]); + IntegerVector strLhs = as(rxSolveDat->mv[RxMv_lhsStr]); if (_globals.gevid != NULL) free(_globals.gevid); - _globals.gevid = (int*)calloc(3*evid.size()+dfN*2+si.size(), sizeof(int)); + _globals.gevid = (int*)calloc(3*evid.size()+dfN*2+si.size() + strLhs.size(), sizeof(int)); if (_globals.gevid == NULL){ rxSolveFree(); stop(_("can not allocate enough memory to load 'evid'")); @@ -3553,7 +3621,8 @@ static inline void rxSolve_datSetupHmax(const RObject &obj, const List &rxContro _globals.gpar_covInterp = _globals.gpar_cov + dfN; // [dfN] _globals.gsi = _globals.gpar_covInterp + dfN;//[si.size()]; std::copy(si.begin(),si.end(), &_globals.gsi[0]); - + _globals.glhs_str = _globals.gsi + si.size(); // [strLhs.siae()] + std::copy(strLhs.begin(),strLhs.end(), &_globals.glhs_str[0]); int ntot = 1; IntegerVector id(evid.size(), 1); @@ -3630,14 +3699,41 @@ static inline void rxSolve_datSetupHmax(const RObject &obj, const List &rxContro std::vector covPos(dfN); curcovi=0; IntegerVector interp0 = as(rxSolveDat->mv[RxMv_interp]); + // + bool isLinearOrMidpointInterp = op->is_locf == 0 || op->is_locf == 3; for (i = dfN; i--;){ - for (j = rxSolveDat->npars; j--;){ + for (j = rx->npars; j--;){ if (pars[j] == dfNames[i]){ _globals.gpar_cov[ncov] = j+1; // We minus 2 here because that way that the covariates // interpolation will match the interpolation method defined in // the rxControl() object + const char *curDf = dfNames[i]; + int curDfN = strlen(curDf); _globals.gpar_covInterp[ncov] = interp0[j] - 2; + if ((isLinearOrMidpointInterp && + _globals.gpar_covInterp[ncov] == -1) || + _globals.gpar_covInterp[ncov] == 0 || + _globals.gpar_covInterp[ncov] == 3) { + // linear or midpoint extrapolation, make sure it isn't a + // character/integer + // factorName.line[0] == "ID" + + // the rest represent the character vectors that should + // not be interpolated with anything by locf / nocb + // change to locf if necessary. + + for (int ifct = 2; ifct < rx->factorNames.n; ++ifct) { + const char *curFactor = rx->factorNames.line[ifct]; + if (!strncmpci(curDf, curFactor, curDfN)) { + // This is a string/factor + _globals.gpar_covInterp[ncov] = 1; // + Rcpp::warning("changed '%s' interpolation to locf", curDf); + break; + } + } + + } covPos[ncov] = i; ncov++; } @@ -3651,6 +3747,7 @@ static inline void rxSolve_datSetupHmax(const RObject &obj, const List &rxContro stop(_("can not allocate memory for the covariates")); } op->par_cov=&(_globals.gpar_cov[0]); + op->lhs_str=&(_globals.glhs_str[0]); op->par_cov_interp = &(_globals.gpar_covInterp[0]); op->ncov=ncov; op->do_par_cov = (ncov > 0); @@ -3804,14 +3901,14 @@ static inline void rxSolve_parOrder(const RObject &obj, const List &rxControl, rx_solve* rx = getRxSolve_(); rx_solving_options* op = rx->op; if (_globals.gParPos != NULL) free(_globals.gParPos); - _globals.gParPos = (int*)calloc(rxSolveDat->npars*2 + + _globals.gParPos = (int*)calloc(rx->npars*2 + rxSolveDat->sigmaN.size() + rxSolveDat->omegaN.size(), sizeof(int));// [npars] if (_globals.gParPos == NULL){ rxSolveFree(); stop(_("cannot allocate enough memory to sort input parameters")); } - _globals.gParPos2 = _globals.gParPos + rxSolveDat->npars; // [npars] - _globals.gsvar = _globals.gParPos2 + rxSolveDat->npars;//[sigmaN.size()] + _globals.gParPos2 = _globals.gParPos + rx->npars; // [npars] + _globals.gsvar = _globals.gParPos2 + rx->npars;//[sigmaN.size()] _globals.govar = _globals.gsvar + rxSolveDat->sigmaN.size(); // [omegaN.size()] std::string errStr = ""; bool allPars = true; @@ -3826,7 +3923,7 @@ static inline void rxSolve_parOrder(const RObject &obj, const List &rxControl, } int i, j; - for (i = rxSolveDat->npars; i--;) { + for (i = rx->npars; i--;) { curPar = false; const char *p0 = CHAR(pars[i]); // Check for the omega-style simulated parameters. @@ -3952,7 +4049,7 @@ static inline void rxSolve_resample(const RObject &obj, rx->sample = true; if (rx->par_sample != NULL) free(rx->par_sample); rx->par_sample = (int*)calloc(pars.size(), sizeof(int)); - for (int ip = rxSolveDat->npars; ip--;){ + for (int ip = rx->npars; ip--;){ for (int is = Rf_length(sampleVars); is--;){ if (!strcmp(pars[ip],CHAR(STRING_ELT(sampleVars, is)))){ rx->par_sample[ip] = 1; @@ -3971,7 +4068,7 @@ static inline void rxSolve_resample(const RObject &obj, parListF = clone(parList); updatePar = true; } - int nrow = rxSolveDat->npars; + int nrow = rx->npars; int ncol = rx->nsub; int size = rx->nsub*rx->nsim; NumericMatrix iniPars(nrow, ncol,&_globals.gpars[0]); @@ -4081,7 +4178,7 @@ static inline void rxSolve_normalizeParms(const RObject &obj, const List &rxCont } case 3: // NumericMatrix { - gparsCovSetup(rxSolveDat->npars, rxSolveDat->nPopPar, rx->nsub*rx->nsim, ev1, rx); + gparsCovSetup(rx->npars, rxSolveDat->nPopPar, rx->nsub*rx->nsim, ev1, rx); rxSolve_assignGpars(rxSolveDat); rxSolve_resample(obj, rxControl, specParams, extraArgs, pars, ev1, inits, rxSolveDat); @@ -4115,7 +4212,7 @@ static inline void rxSolve_normalizeParms(const RObject &obj, const List &rxCont ind = &(rx->subjects[cid]); ind->linCmt = linCmt; setupRxInd(ind, 1); - ind->par_ptr = &_globals.gpars[cid*rxSolveDat->npars]; + ind->par_ptr = &_globals.gpars[cid*rx->npars]; ind->mtime = &_globals.gmtime[rx->nMtime*cid]; if (rx->nMtime > 0) ind->mtime[0]=-1; ind->BadDose = &_globals.gBadDose[op->neq*cid]; @@ -4478,9 +4575,10 @@ static inline void rxSolveSaveRxSolve(rxSolve_t* rxSolveDat){ RObject _curPar; static inline void rxSolve_assignGpars(rxSolve_t* rxSolveDat){ unsigned int i; + rx_solve* rx = getRxSolve_(); for (unsigned int j = 0; j < (unsigned int)rxSolveDat->nPopPar; j++){ - for (unsigned int k = 0; k < (unsigned int)rxSolveDat->npars; k++){ - i = k+rxSolveDat->npars*j; + for (unsigned int k = 0; k < (unsigned int)rx->npars; k++){ + i = k+rx->npars*j; if (ISNA(_globals.gpars[i])){ if (_globals.gParPos[k] == 0){ _globals.gpars[i] = 0; @@ -4544,8 +4642,8 @@ static inline void rxSolve_assignGpars(rxSolve_t* rxSolveDat){ // rxSolveDat->parMat.attr("dimnames") = List::create(R_NilValue, rxSolveDat->parNumeric.attr("names")); // } // RObject ev1=_rxModels[".lastEv1"]; -// std::fill_n(&_globals.gpars[0], rxSolveDat->npars*rxSolveDat->nPopPar, NA_REAL); -// gparsCovSetupConstant(ev1, rxSolveDat->npars); +// std::fill_n(&_globals.gpars[0], rx->npars*rxSolveDat->nPopPar, NA_REAL); +// gparsCovSetupConstant(ev1, rx->npars); // // Setup a possibly new scale. // RObject scale = rxControl[Rxc_scale]; // NumericVector scaleC = rxSetupScale(obj, scale, extraArgs); @@ -4684,6 +4782,8 @@ static inline void iniRx(rx_solve* rx) { rx->cens = 0; rx->limit = 0; rx->safeZero = 1; + rx->safePow = 1; + rx->safeLog = 1; rx->useStdPow = 0; rx->ss2cancelAllPending = false; rx->sumType = 1; // pairwise @@ -4716,6 +4816,8 @@ static inline void iniRx(rx_solve* rx) { op->stiff = 0; op->ncov = 0; op->par_cov = NULL; + op->par_cov_interp = NULL; + op->lhs_str = NULL; op->inits = NULL; op->scale = NULL; op->do_par_cov=false; @@ -4897,7 +4999,13 @@ SEXP rxSolve_(const RObject &obj, const List &rxControl, rxSolveFreeObj = object; } } - + if (rxSolveDat->mv.size() == 0) { + // sometimes the model variables have not been assigned, but this + // needs to be assigned to set the user defined functions + // this is shown indirectly in the backward compatible testing + // where the subscript wasn't defined; See #750 + rxSolveDat->mv = rxModelVars(object); + } _rxode2_udfEnvSet(rxSolveDat->mv[RxMv_udf]); LogicalVector recompileUdf = _rxode2_assignUdf(rxSolveDat->mv[RxMv_udf]); @@ -4957,7 +5065,7 @@ SEXP rxSolve_(const RObject &obj, const List &rxControl, _lastT0 = clock(); #endif// rxSolveT CharacterVector pars = rxSolveDat->mv[RxMv_params]; - rxSolveDat->npars = pars.size(); + rx->npars = pars.size(); rxSolveDat->hasCmt = INTEGER(rxSolveDat->mv[RxMv_flags])[RxMvFlag_hasCmt] == 1; // Assign Pointers rxAssignPtr(rxSolveDat->mv); @@ -4970,6 +5078,8 @@ SEXP rxSolve_(const RObject &obj, const List &rxControl, rx->add_cov = (int)(addCov); rx->istateReset = asInt(rxControl[Rxc_istateReset], "istateReset"); rx->safeZero = asInt(rxControl[Rxc_safeZero], "safeZero"); + rx->safePow = asInt(rxControl[Rxc_safePow], "safePow"); + rx->safeLog = asInt(rxControl[Rxc_safeLog], "safeLog"); rx->useStdPow = asInt(rxControl[Rxc_useStdPow], "useStdPow"); rx->ss2cancelAllPending = asInt(rxControl[Rxc_ss2cancelAllPending], "ss2cancelAllPending"); op->stiff = method; @@ -5271,7 +5381,7 @@ SEXP rxSolve_(const RObject &obj, const List &rxControl, // The event table can contain covariate information, if it is acutally a data frame or matrix. Nullable covnames0, simnames0; CharacterVector covnames, simnames; - rxSolveDat->eGparPos = IntegerVector(rxSolveDat->npars); + rxSolveDat->eGparPos = IntegerVector(rx->npars); CharacterVector state = rxSolveDat->mv[RxMv_state]; CharacterVector lhs = rxSolveDat->mv[RxMv_lhs]; op->neq = state.size(); @@ -5343,6 +5453,7 @@ SEXP rxSolve_(const RObject &obj, const List &rxControl, snprintf(op->modNamePtr, 1000, "%s", (as(trans[RxMvTrans_model_vars])).c_str()); // approx fun options op->instant_backward = asInt(rxControl[Rxc_naInterpolation], "naInterpolation"); + op->keep_interp = asInt(rxControl[Rxc_keepInterpolation], "keepInterpolation"); op->is_locf = covs_interpolation; if (op->is_locf == 0){//linear } else if (op->is_locf == 1){ // locf diff --git a/src/rxData.h b/src/rxData.h index 466d33ea8..521712c5b 100644 --- a/src/rxData.h +++ b/src/rxData.h @@ -7,7 +7,7 @@ #if defined(__cplusplus) extern "C" { #endif - double get_fkeep(int col, int id, rx_solving_options_ind *ind); + double get_fkeep(int col, int id, rx_solving_options_ind *ind, int fid); int get_fkeepType(int col); SEXP get_fkeepLevels(int col); SEXP assign_fkeepAttr(int col, SEXP in); diff --git a/src/rxode2_df.cpp b/src/rxode2_df.cpp index 27f810b0e..a5d1d7a2b 100644 --- a/src/rxode2_df.cpp +++ b/src/rxode2_df.cpp @@ -56,7 +56,7 @@ using namespace arma; extern t_update_inis update_inis; extern t_calc_lhs calc_lhs; -extern "C" SEXP getDfLevels(const char *item, rx_solve *rx){ +extern "C" SEXP getDfLevels(const char *item, rx_solve *rx) { int totN = rx->factorNames.n; int base = 0, curLen= rx->factorNs[0], curG=0; curLen= rx->factorNs[0]; @@ -199,7 +199,7 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { // Multiple simulation data? int sm = 0; if (rx->nsim > 1) sm = 1; - int ncols =1+nPrnState+nlhs; + int ncols =1+nPrnState + nlhs; int ncols2 = add_cov*(ncov+ncov0)+nkeep; int doseCols = 0; int nevid2col = 0; @@ -260,7 +260,27 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { doseCols += nevid2col; CharacterVector paramNames = rxParamNames(op->modNamePtr); CharacterVector fkeepNames = get_fkeepn(); - for (i = md + sm + ms + doseCols + 2*nmevid; i < ncols + doseCols + nidCols + 2*nmevid; i++){ + // time comes in here + df[md + sm +ms + doseCols + 2*nmevid] = NumericVector(rx->nr); + CharacterVector lhsNames = rxLhsNames(op->modNamePtr); + // time + int i0 = md + sm + ms + doseCols + 2*nmevid; + df[i0] = NumericVector(rx->nr); + i0++; + + // nlhs + for (i = i0; i < i0+nlhs; i++){ + if (op->lhs_str[i-i0] == 1) { + // factor; from string expression + df[i] = getDfLevels(CHAR(STRING_ELT(lhsNames, i-i0)), rx); + } else { + df[i] = NumericVector(rx->nr); + } + } + i0+=nlhs; + + // Rest is numeric + for (i = i0; i < ncols + doseCols + nidCols + 2*nmevid; i++){ df[i] = NumericVector(rx->nr); } // These could be factors @@ -352,7 +372,7 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { } handleTlastInline(&curT, ind); } - if (updateErr){ + if (updateErr) { for (j=0; j < errNcol; j++){ // The error pointer is updated if needed par_ptr[svar[j]] = errs[errNrow*j+kk]; @@ -363,7 +383,7 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { kk=min2(kk+1, errNrow-1); } } - if (nlhs){ + if (nlhs) { calc_lhs(neq[1], curT, getSolve(i), ind->lhs); } if (subsetEvid == 1){ @@ -689,9 +709,27 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { // LHS if (nlhs){ for (j = 0; j < nlhs; j++){ - dfp = REAL(VECTOR_ELT(df, jj)); - dfp[ii] =ind->lhs[j]; - jj++; + RObject curR = VECTOR_ELT(df, jj); + if (curR.hasAttribute("levels") && op->lhs_str[j] == 1) { + // factor; from string + IntegerVector cur = VECTOR_ELT(df, jj); + CharacterVector curL = cur.attr("levels"); + dfi = INTEGER(cur); + int len = curL.size(); + if (ISNA(ind->lhs[j])) { + dfi[ii] = NA_INTEGER; + } else { + dfi[ii] = (int)(ind->lhs[j]); + if (dfi[ii] < 1 || dfi[ii] > len) { + dfi[ii] = NA_INTEGER; + } + } + jj++; + } else { + dfp = REAL(VECTOR_ELT(df, jj)); + dfp[ii] =ind->lhs[j]; + jj++; + } } } // States @@ -746,13 +784,13 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { if (TYPEOF(tmp) == REALSXP){ dfp = REAL(tmp); // is this ntimes = nAllTimes or nObs time for this subject...? - dfp[ii] = get_fkeep(j, curi + ind->ix[i], ind); + dfp[ii] = get_fkeep(j, curi + ind->ix[i], ind, curi); } else if (TYPEOF(tmp) == STRSXP){ - SET_STRING_ELT(tmp, ii, get_fkeepChar(j, get_fkeep(j, curi + ind->ix[i], ind))); + SET_STRING_ELT(tmp, ii, get_fkeepChar(j, get_fkeep(j, curi + ind->ix[i], ind, curi))); } else if (TYPEOF(tmp) == LGLSXP) { // Everything here is double dfi = LOGICAL(tmp); - double curD = get_fkeep(j, curi + ind->ix[i], ind); + double curD = get_fkeep(j, curi + ind->ix[i], ind, curi); if (ISNA(curD) || std::isnan(curD)) { dfi[ii] = NA_LOGICAL; } else { @@ -762,7 +800,7 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { dfi = INTEGER(tmp); /* if (j == 0) RSprintf("j: %d, %d; %f\n", j, i, get_fkeep(j, curi + i)); */ // is this ntimes = nAllTimes or nObs time for this subject...? - double curD = get_fkeep(j, curi + ind->ix[i], ind); + double curD = get_fkeep(j, curi + ind->ix[i], ind, curi); if (ISNA(curD) || std::isnan(curD)) { dfi[ii] = NA_INTEGER; } else { @@ -855,7 +893,6 @@ extern "C" SEXP rxode2_df(int doDose0, int doTBS) { jj++; // Put in LHS names - CharacterVector lhsNames = rxLhsNames(op->modNamePtr); for (i = 0; i < nlhs; i++){ sexp_colnames[jj] = STRING_ELT(lhsNames,i); jj++; diff --git a/src/tran.c b/src/tran.c index 8f280baf9..abeef91e6 100644 --- a/src/tran.c +++ b/src/tran.c @@ -14,7 +14,6 @@ #include "genModelVars.h" #include "print_node.h" #include -#include #include #include #include @@ -26,6 +25,15 @@ #else #define _(String) (String) #endif + +// change the name of the iniDparser pointer +#define iniDparserPtr _rxode2_iniDparserPtr + +#include + +dparserPtrIni + + #include "tran.g.d_parser.h" #define MXSYM 50000 @@ -57,7 +65,7 @@ int lastStrLoc=0; SEXP _goodFuns; vLines _dupStrs; -int rx_syntax_error = 0, rx_suppress_syntax_info=0, rx_syntax_require_ode_first = 1; +int rx_syntax_error = 0, rx_suppress_syntax_info=0; extern D_ParserTables parser_tables_rxode2parse; @@ -130,7 +138,7 @@ int depotAttr=0, centralAttr=0; sbuf _gbuf, _mv; -static inline int new_de(const char *s); +static inline int new_de(const char *s, int fromWhere); static inline int handleRemainingAssignmentsCalcProps(nodeInfo ni, char *name, int i, D_ParseNode *pn, D_ParseNode *xpn, char *v); static inline int finalizeLineDdt(nodeInfo ni, char *name); static inline int finalizeLineParam(nodeInfo ni, char *name); @@ -139,10 +147,13 @@ static inline int isCmtLhsStatement(nodeInfo ni, char *name, char *v); //static inline int add_deCmtProp(nodeInfo ni, char *name, char *v, int hasLhs, int fromWhere); static inline void add_de(nodeInfo ni, char *name, char *v, int hasLhs, int fromWhere); +#include "parseAllowAssign.h" #include "parseFuns.h" #include "parseLogical.h" #include "parseIdentifier.h" #include "parseIndLin.h" +#include "parseAssignStr.h" +#include "parseLevels.h" #include "parseStatements.h" #include "parseDfdy.h" #include "parseCmtProperties.h" @@ -178,9 +189,12 @@ static inline int parseNodeAfterRecursion(nodeInfo ni, char *name, D_ParseNode * handleLogicalExpr(ni, name, *i, pn, xpn, isWhile) || handleCmtProperty(ni, name, *i, xpn) || handleDdtAssign(ni, name, *i, pn, xpn) || - handleDdtRhs(ni, name, xpn)) return 1; + handleDdtRhs(ni, name, xpn) || + handleStrAssign(ni, name, *i, pn, xpn) || + handleLevelsStr(ni, name, *i, pn, xpn) || + handleLevelsStr1(ni, name, *i, pn, xpn)) return 1; if (*i==0 && nodeHas(power_expression)) { - aAppendN("),", 2); + aAppendN(",", 1); sAppendN(&sbt, "^", 1); } handleRemainingAssignments(ni, name, *i, pn, xpn); @@ -199,20 +213,17 @@ void wprint_parsetree(D_ParserTables pt, D_ParseNode *pn, int depth, print_node_ handleFunctionArguments(name, depth); // print/change identifier/operator and change operator information (if needed) handleOperatorsOrPrintingIdentifiers(depth, fn, client_data, ni, name, value); - + if (handleLevelStr(ni, name, value)) return; if (nch != 0) { int isWhile=0; if (nodeHas(power_expression)) { - aAppendN("Rx_pow(_as_dbleps(", 18); + aAppendN("Rx_pow(", 7); } for (i = 0; i < nch; i++) { D_ParseNode *xpn = d_get_child(pn, i); - if (parseNodePossiblySkipRecursion(ni, name, pn, xpn, &i, nch, &depth)) continue; - // Recursively parse tree wprint_parsetree(pt, xpn, depth, fn, client_data); - parseNodeAfterRecursion(ni, name, pn, xpn, &i, nch, &depth, &safe_zero, &ii, &found, &isWhile); } @@ -261,6 +272,8 @@ void parseFree(int last) { lineFree(&sbNrmL); lineFree(&(tb.ss)); lineFree(&(tb.de)); + lineFree(&(tb.str)); + lineFree(&(tb.strVal)); lineFree(&depotLines); lineFree(¢ralLines); lineFree(&_dupStrs); @@ -274,7 +287,14 @@ void parseFree(int last) { R_Free(tb.iniv); R_Free(tb.ini0); R_Free(tb.di); + R_Free(tb.didx); + R_Free(tb.dprop); + R_Free(tb.si); + R_Free(tb.sin); + R_Free(tb.strValI); + R_Free(tb.strValII); R_Free(tb.idi); + R_Free(tb.isi); R_Free(tb.idu); R_Free(tb.dvid); R_Free(tb.df); @@ -332,6 +352,7 @@ void reset(void) { lineIni(&(tb.ss)); lineIni(&(tb.de)); + lineIni(&(tb.str)); tb.lh = R_Calloc(MXSYM, int); tb.interp = R_Calloc(MXSYM, int); @@ -341,7 +362,15 @@ void reset(void) { tb.iniv = R_Calloc(MXSYM, double); tb.ini0 = R_Calloc(MXSYM, int); tb.di = R_Calloc(MXDER, int); + tb.didx = R_Calloc(MXDER, int); + tb.dprop = R_Calloc(MXDER, int); + tb.didxn = 1; + tb.si = R_Calloc(MXDER, int); + tb.sin = R_Calloc(MXDER, int); tb.idi = R_Calloc(MXDER, int); + tb.strValI= R_Calloc(MXDER, int); + tb.strValII= R_Calloc(MXDER, int); + tb.isi = R_Calloc(MXDER, int); tb.idu = R_Calloc(MXDER, int); tb.lag = R_Calloc(MXSYM, int); tb.alag = R_Calloc(MXSYM, int); @@ -383,6 +412,8 @@ void reset(void) { tb.hasKa = 0; tb.allocS = MXSYM; tb.allocD = MXDER; + tb.allocS = MXDER; + tb.allocSV = MXDER; tb.matn = 0; tb.matnf = 0; tb.ncmt = 0; @@ -392,6 +423,7 @@ void reset(void) { tb.centralN = -1; tb.linExtra = false; tb.nwhile = 0; + tb.lvlStr = 0; tb.nInd = 0; tb.simflg = 0; tb.nLlik = 0; @@ -544,7 +576,6 @@ static inline int setupTrans(SEXP parse_file, SEXP prefix, SEXP model_md5, SEXP reset(); rx_suppress_syntax_info = R_get_option("rxode2.suppress.syntax.info",0); rx_syntax_allow_ini = R_get_option("rxode2.syntax.allow.ini",1); - rx_syntax_require_ode_first = R_get_option("rxode2.syntax.require.ode.first",1); set_d_use_r_headers(0); set_d_rdebug_grammar_level(0); set_d_verbose_level(0); @@ -687,6 +718,8 @@ void transIniNull(void) { sNull(&(s_inits)); lineNull(&(tb.ss)); lineNull(&(tb.de)); + lineNull(&(tb.str)); + lineNull(&(tb.strVal)); sNull(&(sb)); sNull(&(sbDt)); sNull(&(sbt)); diff --git a/src/tran.g.d_parser.h b/src/tran.g.d_parser.h index b8c598329..ed881c3b6 100644 --- a/src/tran.g.d_parser.h +++ b/src/tran.g.d_parser.h @@ -16,387 +16,418 @@ D_Reduction d_reduction_2_rxode2parse = {2, 2, NULL, NULL, 0, 0, 0, 0, -1, 0, NU D_Reduction d_reduction_3_rxode2parse = {1, 2, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_4_rxode2parse = {1, 3, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_5_rxode2parse = {2, 4, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_25_rxode2parse = {1, 4, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_29_rxode2parse = {3, 5, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_30_rxode2parse = {1, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_31_rxode2parse = {0, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_32_rxode2parse = {9, 7, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_33_rxode2parse = {6, 8, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_34_rxode2parse = {1, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_35_rxode2parse = {0, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_36_rxode2parse = {2, 10, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_37_rxode2parse = {1, 11, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_38_rxode2parse = {3, 12, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_39_rxode2parse = {4, 13, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_40_rxode2parse = {5, 14, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_41_rxode2parse = {2, 15, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_42_rxode2parse = {0, 15, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_43_rxode2parse = {2, 16, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_44_rxode2parse = {1, 17, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_48_rxode2parse = {1, 18, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_52_rxode2parse = {5, 19, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_53_rxode2parse = {2, 20, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_54_rxode2parse = {0, 20, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_55_rxode2parse = {2, 21, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_56_rxode2parse = {1, 22, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_60_rxode2parse = {1, 23, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_64_rxode2parse = {1, 24, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_68_rxode2parse = {5, 25, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_69_rxode2parse = {2, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_70_rxode2parse = {0, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_71_rxode2parse = {2, 27, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_72_rxode2parse = {1, 28, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_75_rxode2parse = {5, 29, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_76_rxode2parse = {2, 30, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_77_rxode2parse = {0, 30, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_78_rxode2parse = {2, 31, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_79_rxode2parse = {2, 32, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_80_rxode2parse = {1, 33, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_81_rxode2parse = {0, 33, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_82_rxode2parse = {4, 34, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_83_rxode2parse = {1, 35, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_85_rxode2parse = {4, 36, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_86_rxode2parse = {1, 37, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_88_rxode2parse = {3, 38, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_89_rxode2parse = {1, 39, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_91_rxode2parse = {7, 40, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_92_rxode2parse = {1, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_94_rxode2parse = {0, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_95_rxode2parse = {1, 42, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_98_rxode2parse = {4, 43, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_99_rxode2parse = {8, 44, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_100_rxode2parse = {1, 45, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_102_rxode2parse = {1, 46, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_106_rxode2parse = {6, 47, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_107_rxode2parse = {1, 48, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_111_rxode2parse = {6, 49, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_112_rxode2parse = {1, 50, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_115_rxode2parse = {1, 51, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_117_rxode2parse = {6, 52, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_118_rxode2parse = {1, 53, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_121_rxode2parse = {1, 54, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_123_rxode2parse = {6, 55, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_124_rxode2parse = {1, 56, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_127_rxode2parse = {6, 57, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_128_rxode2parse = {1, 58, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_131_rxode2parse = {1, 59, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_132_rxode2parse = {2, 60, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_133_rxode2parse = {0, 60, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_134_rxode2parse = {1, 61, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_135_rxode2parse = {3, 62, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_136_rxode2parse = {1, 63, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_139_rxode2parse = {3, 64, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_140_rxode2parse = {3, 65, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_141_rxode2parse = {6, 66, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_142_rxode2parse = {1, 67, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_145_rxode2parse = {2, 68, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_146_rxode2parse = {2, 69, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_147_rxode2parse = {0, 69, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_148_rxode2parse = {2, 70, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_149_rxode2parse = {1, 71, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_151_rxode2parse = {2, 72, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_152_rxode2parse = {2, 73, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_153_rxode2parse = {0, 73, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_154_rxode2parse = {2, 74, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_155_rxode2parse = {1, 75, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_157_rxode2parse = {1, 76, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_158_rxode2parse = {3, 76, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_159_rxode2parse = {4, 76, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_164_rxode2parse = {2, 76, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_166_rxode2parse = {1, 77, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_168_rxode2parse = {3, 78, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_169_rxode2parse = {1, 79, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_171_rxode2parse = {3, 80, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_172_rxode2parse = {1, 81, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_174_rxode2parse = {2, 82, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_175_rxode2parse = {2, 83, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_176_rxode2parse = {0, 83, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_177_rxode2parse = {2, 84, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_178_rxode2parse = {1, 85, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_180_rxode2parse = {1, 86, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_186_rxode2parse = {2, 87, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_187_rxode2parse = {2, 88, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_188_rxode2parse = {0, 88, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_189_rxode2parse = {2, 89, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_190_rxode2parse = {2, 90, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_191_rxode2parse = {2, 91, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_192_rxode2parse = {0, 91, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_193_rxode2parse = {2, 92, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_194_rxode2parse = {1, 93, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_196_rxode2parse = {2, 94, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_197_rxode2parse = {2, 95, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_198_rxode2parse = {0, 95, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_199_rxode2parse = {1, 96, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_200_rxode2parse = {2, 97, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_201_rxode2parse = {1, 98, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_203_rxode2parse = {2, 99, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_204_rxode2parse = {1, 100, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_209_rxode2parse = {1, 101, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_210_rxode2parse = {0, 101, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_211_rxode2parse = {1, 102, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_213_rxode2parse = {2, 103, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_214_rxode2parse = {1, 104, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_218_rxode2parse = {1, 105, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_219_rxode2parse = {0, 105, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_220_rxode2parse = {1, 106, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_222_rxode2parse = {3, 107, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_223_rxode2parse = {1, 108, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_224_rxode2parse = {1, 109, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_226_rxode2parse = {1, 110, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_235_rxode2parse = {3, 110, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_236_rxode2parse = {8, 111, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_237_rxode2parse = {5, 112, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_238_rxode2parse = {2, 113, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_239_rxode2parse = {0, 113, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_240_rxode2parse = {2, 114, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_241_rxode2parse = {2, 115, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_242_rxode2parse = {0, 115, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_243_rxode2parse = {1, 116, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_244_rxode2parse = {1, 117, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_246_rxode2parse = {2, 118, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_247_rxode2parse = {1, 119, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_248_rxode2parse = {0, 119, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_249_rxode2parse = {1, 120, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_250_rxode2parse = {2, 120, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_251_rxode2parse = {1, 121, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_252_rxode2parse = {0, 121, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_253_rxode2parse = {1, 122, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_256_rxode2parse = {1, 123, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_259_rxode2parse = {1, 124, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_28_rxode2parse = {1, 4, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_32_rxode2parse = {3, 5, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_33_rxode2parse = {1, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_34_rxode2parse = {0, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_35_rxode2parse = {9, 7, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_36_rxode2parse = {6, 8, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_37_rxode2parse = {1, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_38_rxode2parse = {0, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_39_rxode2parse = {2, 10, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_40_rxode2parse = {1, 11, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_41_rxode2parse = {3, 12, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_42_rxode2parse = {4, 13, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_43_rxode2parse = {5, 14, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_44_rxode2parse = {2, 15, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_45_rxode2parse = {0, 15, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_46_rxode2parse = {2, 16, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_47_rxode2parse = {1, 17, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_51_rxode2parse = {1, 18, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_55_rxode2parse = {5, 19, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_56_rxode2parse = {2, 20, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_57_rxode2parse = {0, 20, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_58_rxode2parse = {2, 21, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_59_rxode2parse = {1, 22, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_63_rxode2parse = {1, 23, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_67_rxode2parse = {1, 24, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_71_rxode2parse = {5, 25, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_72_rxode2parse = {2, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_73_rxode2parse = {0, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_74_rxode2parse = {2, 27, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_75_rxode2parse = {1, 28, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_78_rxode2parse = {5, 29, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_79_rxode2parse = {2, 30, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_80_rxode2parse = {0, 30, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_81_rxode2parse = {2, 31, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_82_rxode2parse = {2, 32, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_83_rxode2parse = {1, 33, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_84_rxode2parse = {0, 33, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_85_rxode2parse = {4, 34, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_86_rxode2parse = {1, 35, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_88_rxode2parse = {4, 36, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_89_rxode2parse = {1, 37, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_91_rxode2parse = {3, 38, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_92_rxode2parse = {1, 39, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_94_rxode2parse = {7, 40, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_95_rxode2parse = {1, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_97_rxode2parse = {0, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_98_rxode2parse = {1, 42, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_101_rxode2parse = {4, 43, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_102_rxode2parse = {8, 44, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_103_rxode2parse = {1, 45, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_105_rxode2parse = {1, 46, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_109_rxode2parse = {6, 47, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_110_rxode2parse = {1, 48, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_114_rxode2parse = {6, 49, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_115_rxode2parse = {1, 50, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_118_rxode2parse = {1, 51, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_120_rxode2parse = {6, 52, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_121_rxode2parse = {1, 53, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_124_rxode2parse = {1, 54, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_126_rxode2parse = {6, 55, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_127_rxode2parse = {1, 56, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_130_rxode2parse = {6, 57, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_131_rxode2parse = {1, 58, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_134_rxode2parse = {1, 59, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_135_rxode2parse = {2, 60, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_136_rxode2parse = {0, 60, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_137_rxode2parse = {1, 61, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_138_rxode2parse = {3, 62, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_139_rxode2parse = {1, 63, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_142_rxode2parse = {3, 64, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_143_rxode2parse = {1, 65, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_146_rxode2parse = {10, 66, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_147_rxode2parse = {2, 67, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_148_rxode2parse = {0, 67, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_149_rxode2parse = {2, 68, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_150_rxode2parse = {1, 69, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_153_rxode2parse = {6, 70, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_154_rxode2parse = {1, 71, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_157_rxode2parse = {3, 72, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_158_rxode2parse = {3, 73, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_159_rxode2parse = {6, 74, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_160_rxode2parse = {1, 75, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_163_rxode2parse = {2, 76, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_164_rxode2parse = {2, 77, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_165_rxode2parse = {0, 77, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_166_rxode2parse = {2, 78, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_167_rxode2parse = {1, 79, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_169_rxode2parse = {2, 80, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_170_rxode2parse = {2, 81, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_171_rxode2parse = {0, 81, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_172_rxode2parse = {2, 82, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_173_rxode2parse = {1, 83, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_175_rxode2parse = {1, 84, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_176_rxode2parse = {3, 84, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_177_rxode2parse = {4, 84, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_182_rxode2parse = {2, 84, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_184_rxode2parse = {1, 85, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_186_rxode2parse = {3, 86, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_187_rxode2parse = {1, 87, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_189_rxode2parse = {3, 88, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_190_rxode2parse = {1, 89, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_192_rxode2parse = {2, 90, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_193_rxode2parse = {2, 91, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_194_rxode2parse = {0, 91, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_195_rxode2parse = {2, 92, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_196_rxode2parse = {1, 93, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_198_rxode2parse = {1, 94, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_204_rxode2parse = {2, 95, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_205_rxode2parse = {2, 96, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_206_rxode2parse = {0, 96, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_207_rxode2parse = {2, 97, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_208_rxode2parse = {2, 98, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_209_rxode2parse = {2, 99, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_210_rxode2parse = {0, 99, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_211_rxode2parse = {2, 100, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_212_rxode2parse = {1, 101, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_214_rxode2parse = {2, 102, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_215_rxode2parse = {2, 103, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_216_rxode2parse = {0, 103, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_217_rxode2parse = {1, 104, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_218_rxode2parse = {2, 105, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_219_rxode2parse = {1, 106, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_221_rxode2parse = {2, 107, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_222_rxode2parse = {1, 108, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_227_rxode2parse = {1, 109, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_228_rxode2parse = {0, 109, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_229_rxode2parse = {1, 110, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_231_rxode2parse = {2, 111, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_232_rxode2parse = {1, 112, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_236_rxode2parse = {1, 113, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_237_rxode2parse = {0, 113, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_238_rxode2parse = {1, 114, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_240_rxode2parse = {3, 115, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_241_rxode2parse = {1, 116, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_242_rxode2parse = {1, 117, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_244_rxode2parse = {1, 118, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_253_rxode2parse = {3, 118, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_254_rxode2parse = {8, 119, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_255_rxode2parse = {5, 120, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_256_rxode2parse = {2, 121, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_257_rxode2parse = {0, 121, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_258_rxode2parse = {2, 122, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_259_rxode2parse = {2, 123, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_260_rxode2parse = {0, 123, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_261_rxode2parse = {1, 124, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_262_rxode2parse = {1, 125, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_268_rxode2parse = {4, 126, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_269_rxode2parse = {1, 127, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_271_rxode2parse = {4, 128, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_272_rxode2parse = {1, 129, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_274_rxode2parse = {1, 130, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_275_rxode2parse = {1, 131, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_279_rxode2parse = {4, 132, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_280_rxode2parse = {1, 133, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_282_rxode2parse = {4, 134, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_283_rxode2parse = {1, 135, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_285_rxode2parse = {1, 136, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_286_rxode2parse = {1, 137, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_290_rxode2parse = {1, 138, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_291_rxode2parse = {1, 139, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_292_rxode2parse = {1, 140, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_293_rxode2parse = {1, 141, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_294_rxode2parse = {1, 142, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_295_rxode2parse = {1, 143, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_296_rxode2parse = {1, 144, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_297_rxode2parse = {1, 145, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_298_rxode2parse = {1, 146, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_299_rxode2parse = {1, 147, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_300_rxode2parse = {1, 148, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Reduction d_reduction_301_rxode2parse = {2, 149, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_302_rxode2parse = {0, 149, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_303_rxode2parse = {1, 150, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; -D_Reduction d_reduction_305_rxode2parse = {2, 151, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_0_rxode2parse = {152, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_1_rxode2parse = {153, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_2_rxode2parse = {154, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_3_rxode2parse = {155, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_4_rxode2parse = {156, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_5_rxode2parse = {157, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_6_rxode2parse = {158, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_7_rxode2parse = {159, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_8_rxode2parse = {160, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_9_rxode2parse = {161, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_10_rxode2parse = {162, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_11_rxode2parse = {163, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_12_rxode2parse = {164, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_13_rxode2parse = {165, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_14_rxode2parse = {166, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_15_rxode2parse = {167, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_16_rxode2parse = {168, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_17_rxode2parse = {169, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_18_rxode2parse = {170, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_19_rxode2parse = {171, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_20_rxode2parse = {172, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_21_rxode2parse = {173, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_22_rxode2parse = {174, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_23_rxode2parse = {175, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_24_rxode2parse = {176, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_25_rxode2parse = {177, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_26_rxode2parse = {178, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_27_rxode2parse = {179, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_28_rxode2parse = {180, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_29_rxode2parse = {181, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_30_rxode2parse = {182, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_31_rxode2parse = {183, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_32_rxode2parse = {184, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_33_rxode2parse = {185, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_34_rxode2parse = {186, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_35_rxode2parse = {187, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_36_rxode2parse = {188, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_37_rxode2parse = {189, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_38_rxode2parse = {190, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_39_rxode2parse = {191, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_40_rxode2parse = {192, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_41_rxode2parse = {193, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_42_rxode2parse = {194, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_43_rxode2parse = {195, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_44_rxode2parse = {196, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_45_rxode2parse = {197, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_46_rxode2parse = {198, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_47_rxode2parse = {199, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_48_rxode2parse = {200, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_49_rxode2parse = {201, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_50_rxode2parse = {202, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_51_rxode2parse = {203, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_52_rxode2parse = {204, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_53_rxode2parse = {205, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_54_rxode2parse = {206, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_55_rxode2parse = {207, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_56_rxode2parse = {208, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_57_rxode2parse = {209, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_58_rxode2parse = {210, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_59_rxode2parse = {211, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_60_rxode2parse = {212, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_61_rxode2parse = {213, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_62_rxode2parse = {214, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_63_rxode2parse = {215, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_64_rxode2parse = {216, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_65_rxode2parse = {217, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_66_rxode2parse = {218, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_67_rxode2parse = {219, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_68_rxode2parse = {220, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_69_rxode2parse = {221, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_70_rxode2parse = {222, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_71_rxode2parse = {223, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_72_rxode2parse = {224, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_73_rxode2parse = {225, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_74_rxode2parse = {226, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_75_rxode2parse = {227, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_76_rxode2parse = {228, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_77_rxode2parse = {229, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_78_rxode2parse = {230, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_79_rxode2parse = {231, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_80_rxode2parse = {232, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_81_rxode2parse = {233, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_82_rxode2parse = {234, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_83_rxode2parse = {235, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_84_rxode2parse = {236, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_85_rxode2parse = {237, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_86_rxode2parse = {238, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_87_rxode2parse = {239, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_88_rxode2parse = {240, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_89_rxode2parse = {241, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_90_rxode2parse = {242, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_91_rxode2parse = {243, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_92_rxode2parse = {244, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_93_rxode2parse = {245, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_94_rxode2parse = {246, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_95_rxode2parse = {247, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_96_rxode2parse = {248, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_97_rxode2parse = {249, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_98_rxode2parse = {250, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_99_rxode2parse = {251, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_100_rxode2parse = {252, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_101_rxode2parse = {253, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_102_rxode2parse = {254, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_103_rxode2parse = {255, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_104_rxode2parse = {256, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_105_rxode2parse = {257, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_106_rxode2parse = {258, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_107_rxode2parse = {259, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_108_rxode2parse = {260, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_109_rxode2parse = {261, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_110_rxode2parse = {262, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_111_rxode2parse = {263, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_112_rxode2parse = {264, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_113_rxode2parse = {265, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_114_rxode2parse = {266, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_115_rxode2parse = {267, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_116_rxode2parse = {268, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_117_rxode2parse = {269, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_118_rxode2parse = {270, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_119_rxode2parse = {271, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_120_rxode2parse = {272, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_121_rxode2parse = {273, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_122_rxode2parse = {274, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_123_rxode2parse = {275, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_124_rxode2parse = {276, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_125_rxode2parse = {277, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_126_rxode2parse = {278, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_127_rxode2parse = {279, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_128_rxode2parse = {280, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_129_rxode2parse = {281, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_130_rxode2parse = {282, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_131_rxode2parse = {283, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_132_rxode2parse = {284, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_133_rxode2parse = {285, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_134_rxode2parse = {286, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_135_rxode2parse = {287, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_136_rxode2parse = {288, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_137_rxode2parse = {289, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_138_rxode2parse = {290, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_139_rxode2parse = {291, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_140_rxode2parse = {292, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_141_rxode2parse = {293, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_142_rxode2parse = {294, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_143_rxode2parse = {295, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_144_rxode2parse = {296, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_145_rxode2parse = {297, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_146_rxode2parse = {298, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_147_rxode2parse = {299, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_148_rxode2parse = {300, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_149_rxode2parse = {301, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_150_rxode2parse = {302, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_151_rxode2parse = {303, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_152_rxode2parse = {304, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_153_rxode2parse = {305, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_154_rxode2parse = {306, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_155_rxode2parse = {307, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_156_rxode2parse = {308, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_157_rxode2parse = {309, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_158_rxode2parse = {310, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_159_rxode2parse = {311, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_160_rxode2parse = {312, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_161_rxode2parse = {313, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_162_rxode2parse = {314, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_163_rxode2parse = {315, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_164_rxode2parse = {316, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_165_rxode2parse = {317, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_166_rxode2parse = {318, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_167_rxode2parse = {319, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_168_rxode2parse = {320, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_169_rxode2parse = {321, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_170_rxode2parse = {322, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_171_rxode2parse = {323, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_172_rxode2parse = {324, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_173_rxode2parse = {325, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_174_rxode2parse = {326, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_175_rxode2parse = {327, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_176_rxode2parse = {328, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_177_rxode2parse = {329, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_178_rxode2parse = {330, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_179_rxode2parse = {331, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_180_rxode2parse = {332, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_181_rxode2parse = {333, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_182_rxode2parse = {334, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_183_rxode2parse = {335, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_184_rxode2parse = {336, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_185_rxode2parse = {337, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_186_rxode2parse = {338, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_187_rxode2parse = {339, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_188_rxode2parse = {340, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_189_rxode2parse = {341, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_190_rxode2parse = {342, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_191_rxode2parse = {343, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_192_rxode2parse = {344, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_193_rxode2parse = {345, 0, 0, 0, -1, 0, NULL}; -D_Shift d_shift_194_rxode2parse = {346, 0, 0, 0, -1, 0, NULL}; -D_Shift d_shift_195_rxode2parse = {347, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_196_rxode2parse = {348, 0, 0, 0, -2, 0, NULL}; -D_Shift d_shift_197_rxode2parse = {349, 0, 0, 0, -3, 0, NULL}; -D_Shift d_shift_198_rxode2parse = {350, 0, 0, 0, -4, 0, NULL}; -D_Shift d_shift_199_rxode2parse = {351, 0, 0, 0, -4, 0, NULL}; -D_Shift d_shift_200_rxode2parse = {352, 0, 0, 0, -4, 0, NULL}; -D_Shift d_shift_201_rxode2parse = {353, 0, 0, 0, -4, 0, NULL}; -D_Shift d_shift_202_rxode2parse = {354, 0, 0, 0, -4, 0, NULL}; -D_Shift d_shift_203_rxode2parse = {355, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_204_rxode2parse = {356, 0, 0, 0, 0, 0, NULL}; -D_Shift d_shift_205_rxode2parse = {357, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_264_rxode2parse = {2, 126, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_265_rxode2parse = {1, 127, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_266_rxode2parse = {0, 127, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_267_rxode2parse = {1, 128, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_268_rxode2parse = {2, 128, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_269_rxode2parse = {1, 129, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_270_rxode2parse = {0, 129, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_271_rxode2parse = {1, 130, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_274_rxode2parse = {1, 131, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_277_rxode2parse = {1, 132, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_280_rxode2parse = {1, 133, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_286_rxode2parse = {4, 134, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_287_rxode2parse = {1, 135, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_289_rxode2parse = {4, 136, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_290_rxode2parse = {1, 137, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_292_rxode2parse = {1, 138, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_293_rxode2parse = {1, 139, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_297_rxode2parse = {4, 140, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_298_rxode2parse = {1, 141, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_300_rxode2parse = {4, 142, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_301_rxode2parse = {1, 143, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_303_rxode2parse = {1, 144, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_304_rxode2parse = {1, 145, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_308_rxode2parse = {1, 146, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_309_rxode2parse = {1, 147, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_310_rxode2parse = {1, 148, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_312_rxode2parse = {1, 149, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_313_rxode2parse = {1, 150, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_314_rxode2parse = {1, 151, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_315_rxode2parse = {1, 152, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_316_rxode2parse = {1, 153, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_317_rxode2parse = {1, 154, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_318_rxode2parse = {1, 155, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_319_rxode2parse = {1, 156, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_320_rxode2parse = {1, 157, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_321_rxode2parse = {1, 158, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Reduction d_reduction_322_rxode2parse = {2, 159, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_323_rxode2parse = {0, 159, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_324_rxode2parse = {1, 160, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; +D_Reduction d_reduction_326_rxode2parse = {2, 161, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_0_rxode2parse = {162, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_1_rxode2parse = {163, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_2_rxode2parse = {164, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_3_rxode2parse = {165, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_4_rxode2parse = {166, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_5_rxode2parse = {167, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_6_rxode2parse = {168, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_7_rxode2parse = {169, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_8_rxode2parse = {170, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_9_rxode2parse = {171, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_10_rxode2parse = {172, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_11_rxode2parse = {173, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_12_rxode2parse = {174, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_13_rxode2parse = {175, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_14_rxode2parse = {176, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_15_rxode2parse = {177, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_16_rxode2parse = {178, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_17_rxode2parse = {179, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_18_rxode2parse = {180, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_19_rxode2parse = {181, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_20_rxode2parse = {182, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_21_rxode2parse = {183, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_22_rxode2parse = {184, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_23_rxode2parse = {185, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_24_rxode2parse = {186, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_25_rxode2parse = {187, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_26_rxode2parse = {188, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_27_rxode2parse = {189, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_28_rxode2parse = {190, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_29_rxode2parse = {191, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_30_rxode2parse = {192, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_31_rxode2parse = {193, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_32_rxode2parse = {194, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_33_rxode2parse = {195, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_34_rxode2parse = {196, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_35_rxode2parse = {197, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_36_rxode2parse = {198, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_37_rxode2parse = {199, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_38_rxode2parse = {200, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_39_rxode2parse = {201, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_40_rxode2parse = {202, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_41_rxode2parse = {203, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_42_rxode2parse = {204, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_43_rxode2parse = {205, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_44_rxode2parse = {206, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_45_rxode2parse = {207, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_46_rxode2parse = {208, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_47_rxode2parse = {209, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_48_rxode2parse = {210, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_49_rxode2parse = {211, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_50_rxode2parse = {212, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_51_rxode2parse = {213, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_52_rxode2parse = {214, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_53_rxode2parse = {215, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_54_rxode2parse = {216, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_55_rxode2parse = {217, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_56_rxode2parse = {218, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_57_rxode2parse = {219, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_58_rxode2parse = {220, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_59_rxode2parse = {221, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_60_rxode2parse = {222, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_61_rxode2parse = {223, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_62_rxode2parse = {224, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_63_rxode2parse = {225, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_64_rxode2parse = {226, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_65_rxode2parse = {227, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_66_rxode2parse = {228, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_67_rxode2parse = {229, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_68_rxode2parse = {230, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_69_rxode2parse = {231, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_70_rxode2parse = {232, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_71_rxode2parse = {233, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_72_rxode2parse = {234, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_73_rxode2parse = {235, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_74_rxode2parse = {236, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_75_rxode2parse = {237, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_76_rxode2parse = {238, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_77_rxode2parse = {239, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_78_rxode2parse = {240, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_79_rxode2parse = {241, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_80_rxode2parse = {242, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_81_rxode2parse = {243, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_82_rxode2parse = {244, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_83_rxode2parse = {245, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_84_rxode2parse = {246, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_85_rxode2parse = {247, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_86_rxode2parse = {248, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_87_rxode2parse = {249, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_88_rxode2parse = {250, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_89_rxode2parse = {251, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_90_rxode2parse = {252, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_91_rxode2parse = {253, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_92_rxode2parse = {254, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_93_rxode2parse = {255, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_94_rxode2parse = {256, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_95_rxode2parse = {257, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_96_rxode2parse = {258, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_97_rxode2parse = {259, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_98_rxode2parse = {260, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_99_rxode2parse = {261, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_100_rxode2parse = {262, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_101_rxode2parse = {263, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_102_rxode2parse = {264, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_103_rxode2parse = {265, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_104_rxode2parse = {266, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_105_rxode2parse = {267, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_106_rxode2parse = {268, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_107_rxode2parse = {269, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_108_rxode2parse = {270, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_109_rxode2parse = {271, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_110_rxode2parse = {272, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_111_rxode2parse = {273, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_112_rxode2parse = {274, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_113_rxode2parse = {275, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_114_rxode2parse = {276, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_115_rxode2parse = {277, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_116_rxode2parse = {278, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_117_rxode2parse = {279, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_118_rxode2parse = {280, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_119_rxode2parse = {281, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_120_rxode2parse = {282, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_121_rxode2parse = {283, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_122_rxode2parse = {284, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_123_rxode2parse = {285, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_124_rxode2parse = {286, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_125_rxode2parse = {287, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_126_rxode2parse = {288, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_127_rxode2parse = {289, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_128_rxode2parse = {290, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_129_rxode2parse = {291, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_130_rxode2parse = {292, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_131_rxode2parse = {293, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_132_rxode2parse = {294, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_133_rxode2parse = {295, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_134_rxode2parse = {296, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_135_rxode2parse = {297, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_136_rxode2parse = {298, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_137_rxode2parse = {299, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_138_rxode2parse = {300, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_139_rxode2parse = {301, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_140_rxode2parse = {302, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_141_rxode2parse = {303, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_142_rxode2parse = {304, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_143_rxode2parse = {305, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_144_rxode2parse = {306, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_145_rxode2parse = {307, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_146_rxode2parse = {308, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_147_rxode2parse = {309, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_148_rxode2parse = {310, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_149_rxode2parse = {311, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_150_rxode2parse = {312, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_151_rxode2parse = {313, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_152_rxode2parse = {314, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_153_rxode2parse = {315, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_154_rxode2parse = {316, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_155_rxode2parse = {317, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_156_rxode2parse = {318, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_157_rxode2parse = {319, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_158_rxode2parse = {320, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_159_rxode2parse = {321, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_160_rxode2parse = {322, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_161_rxode2parse = {323, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_162_rxode2parse = {324, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_163_rxode2parse = {325, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_164_rxode2parse = {326, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_165_rxode2parse = {327, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_166_rxode2parse = {328, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_167_rxode2parse = {329, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_168_rxode2parse = {330, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_169_rxode2parse = {331, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_170_rxode2parse = {332, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_171_rxode2parse = {333, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_172_rxode2parse = {334, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_173_rxode2parse = {335, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_174_rxode2parse = {336, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_175_rxode2parse = {337, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_176_rxode2parse = {338, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_177_rxode2parse = {339, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_178_rxode2parse = {340, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_179_rxode2parse = {341, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_180_rxode2parse = {342, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_181_rxode2parse = {343, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_182_rxode2parse = {344, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_183_rxode2parse = {345, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_184_rxode2parse = {346, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_185_rxode2parse = {347, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_186_rxode2parse = {348, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_187_rxode2parse = {349, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_188_rxode2parse = {350, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_189_rxode2parse = {351, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_190_rxode2parse = {352, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_191_rxode2parse = {353, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_192_rxode2parse = {354, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_193_rxode2parse = {355, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_194_rxode2parse = {356, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_195_rxode2parse = {357, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_196_rxode2parse = {358, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_197_rxode2parse = {359, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_198_rxode2parse = {360, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_199_rxode2parse = {361, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_200_rxode2parse = {362, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_201_rxode2parse = {363, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_202_rxode2parse = {364, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_203_rxode2parse = {365, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_204_rxode2parse = {366, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_205_rxode2parse = {367, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_206_rxode2parse = {368, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_207_rxode2parse = {369, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_208_rxode2parse = {370, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_209_rxode2parse = {371, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_210_rxode2parse = {372, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_211_rxode2parse = {373, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_212_rxode2parse = {374, 0, 0, 0, -1, 0, NULL}; +D_Shift d_shift_213_rxode2parse = {375, 0, 0, 0, -1, 0, NULL}; +D_Shift d_shift_214_rxode2parse = {376, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_215_rxode2parse = {377, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_216_rxode2parse = {378, 0, 0, 0, -2, 0, NULL}; +D_Shift d_shift_217_rxode2parse = {379, 0, 0, 0, -3, 0, NULL}; +D_Shift d_shift_218_rxode2parse = {380, 0, 0, 0, -4, 0, NULL}; +D_Shift d_shift_219_rxode2parse = {381, 0, 0, 0, -4, 0, NULL}; +D_Shift d_shift_220_rxode2parse = {382, 0, 0, 0, -4, 0, NULL}; +D_Shift d_shift_221_rxode2parse = {383, 0, 0, 0, -4, 0, NULL}; +D_Shift d_shift_222_rxode2parse = {384, 0, 0, 0, -4, 0, NULL}; +D_Shift d_shift_223_rxode2parse = {385, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_224_rxode2parse = {386, 0, 0, 0, 0, 0, NULL}; +D_Shift d_shift_225_rxode2parse = {387, 0, 0, 0, 0, 0, NULL}; D_Shift * d_accepts_diff_0_0_rxode2parse[] = {0}; D_Shift * d_accepts_diff_0_1_rxode2parse[] = {&d_shift_83_rxode2parse,0}; @@ -407,21 +438,22 @@ D_Shift * d_accepts_diff_0_5_rxode2parse[] = {&d_shift_33_rxode2parse,0}; D_Shift * d_accepts_diff_0_6_rxode2parse[] = {&d_shift_7_rxode2parse,0}; D_Shift * d_accepts_diff_0_7_rxode2parse[] = {&d_shift_34_rxode2parse,0}; D_Shift * d_accepts_diff_0_8_rxode2parse[] = {&d_shift_11_rxode2parse,0}; -D_Shift * d_accepts_diff_0_9_rxode2parse[] = {&d_shift_35_rxode2parse,0}; -D_Shift * d_accepts_diff_0_10_rxode2parse[] = {&d_shift_12_rxode2parse,0}; -D_Shift * d_accepts_diff_0_11_rxode2parse[] = {&d_shift_15_rxode2parse,0}; -D_Shift * d_accepts_diff_0_12_rxode2parse[] = {&d_shift_103_rxode2parse,0}; +D_Shift * d_accepts_diff_0_9_rxode2parse[] = {&d_shift_102_rxode2parse,0}; +D_Shift * d_accepts_diff_0_10_rxode2parse[] = {&d_shift_35_rxode2parse,0}; +D_Shift * d_accepts_diff_0_11_rxode2parse[] = {&d_shift_12_rxode2parse,0}; +D_Shift * d_accepts_diff_0_12_rxode2parse[] = {&d_shift_15_rxode2parse,0}; D_Shift * d_accepts_diff_0_13_rxode2parse[] = {&d_shift_59_rxode2parse,0}; D_Shift * d_accepts_diff_0_14_rxode2parse[] = {&d_shift_18_rxode2parse,0}; -D_Shift * d_accepts_diff_0_15_rxode2parse[] = {&d_shift_198_rxode2parse,0}; +D_Shift * d_accepts_diff_0_15_rxode2parse[] = {&d_shift_122_rxode2parse,0}; D_Shift * d_accepts_diff_0_16_rxode2parse[] = {&d_shift_69_rxode2parse,0}; D_Shift * d_accepts_diff_0_17_rxode2parse[] = {&d_shift_22_rxode2parse,0}; -D_Shift * d_accepts_diff_0_18_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift * d_accepts_diff_0_19_rxode2parse[] = {&d_shift_23_rxode2parse,0}; -D_Shift * d_accepts_diff_0_20_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift * d_accepts_diff_0_21_rxode2parse[] = {&d_shift_24_rxode2parse,0}; -D_Shift * d_accepts_diff_0_22_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift * d_accepts_diff_0_23_rxode2parse[] = {&d_shift_25_rxode2parse,0}; +D_Shift * d_accepts_diff_0_18_rxode2parse[] = {&d_shift_218_rxode2parse,0}; +D_Shift * d_accepts_diff_0_19_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift * d_accepts_diff_0_20_rxode2parse[] = {&d_shift_23_rxode2parse,0}; +D_Shift * d_accepts_diff_0_21_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift * d_accepts_diff_0_22_rxode2parse[] = {&d_shift_24_rxode2parse,0}; +D_Shift * d_accepts_diff_0_23_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_0_24_rxode2parse[] = {&d_shift_25_rxode2parse,0}; D_Shift ** d_accepts_diff_0_rxode2parse[] = { d_accepts_diff_0_0_rxode2parse, d_accepts_diff_0_1_rxode2parse, @@ -446,7 +478,8 @@ d_accepts_diff_0_19_rxode2parse, d_accepts_diff_0_20_rxode2parse, d_accepts_diff_0_21_rxode2parse, d_accepts_diff_0_22_rxode2parse, -d_accepts_diff_0_23_rxode2parse +d_accepts_diff_0_23_rxode2parse, +d_accepts_diff_0_24_rxode2parse }; unsigned char d_scanner_0_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { @@ -498,20 +531,20 @@ unsigned char d_scanner_0_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_2_rxode2parse[] = {&d_shift_198_rxode2parse,NULL}; +D_Shift * d_shift_0_2_rxode2parse[] = {&d_shift_218_rxode2parse,NULL}; unsigned char d_accepts_diff_0_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, -18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, 0, }; unsigned char d_accepts_diff_0_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, -18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 18, -0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, -18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, +0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 19, +0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, }; D_Shift * d_shift_0_3_rxode2parse[] = {&d_shift_70_rxode2parse,NULL}; @@ -561,7 +594,7 @@ unsigned char d_scanner_0_9_0_rxode2parse[SCANNER_BLOCK_SIZE] = { unsigned char d_accepts_diff_0_9_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; @@ -598,49 +631,49 @@ unsigned char d_scanner_0_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { unsigned char d_scanner_0_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 32, 3, 3, 3, 3, 3, 3, 3, 33, 3, 3, 3, 3, 3, 34, +0, 32, 3, 3, 3, 33, 3, 3, 3, 34, 3, 3, 3, 3, 3, 35, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 35, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 36, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 3, 3, 3, 3, 3, 3, 36, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 37, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 37, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 38, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 38, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 39, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 39, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 40, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 40, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 41, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 41, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 42, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 42, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 43, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; @@ -653,33 +686,33 @@ unsigned char d_scanner_0_20_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_20_rxode2parse[] = {&d_shift_200_rxode2parse,NULL}; +D_Shift * d_shift_0_20_rxode2parse[] = {&d_shift_220_rxode2parse,NULL}; unsigned char d_scanner_0_21_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 43, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 44, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_22_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 45, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 46, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 46, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 47, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; @@ -687,13 +720,13 @@ unsigned char d_scanner_0_25_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 47, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 3, 48, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_26_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; @@ -717,13 +750,13 @@ unsigned char d_scanner_0_28_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 49, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 50, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_29_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 50, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 51, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; @@ -737,7 +770,7 @@ unsigned char d_accepts_diff_0_30_0_rxode2parse[SCANNER_BLOCK_SIZE] = { unsigned char d_scanner_0_30_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 51, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 52, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; @@ -753,646 +786,690 @@ D_Shift * d_shift_0_30_rxode2parse[] = {&d_shift_7_rxode2parse,NULL}; unsigned char d_scanner_0_31_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 52, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 53, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_32_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 53, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 54, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_33_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 54, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 55, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_34_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 55, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 56, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_35_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 56, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 57, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_36_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 57, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 58, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_37_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 58, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 59, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_38_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 59, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 60, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_39_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 60, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 3, 3, 3, 3, 3, 3, 61, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_40_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 61, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 62, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_41_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 62, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 63, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_42_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 63, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 64, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_43_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 65, 0, 0, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 65, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +}; + +unsigned char d_scanner_0_44_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_44_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_45_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 66, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 68, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_45_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_46_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 67, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 69, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_46_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_47_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, -11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_46_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, -11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 11, -0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, -11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_47_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 12, +0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_46_rxode2parse[] = {&d_shift_15_rxode2parse,NULL}; +D_Shift * d_shift_0_47_rxode2parse[] = {&d_shift_15_rxode2parse,NULL}; -unsigned char d_scanner_0_47_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_48_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_48_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_49_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_48_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_49_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_48_rxode2parse[] = {&d_shift_89_rxode2parse,NULL}; +D_Shift * d_shift_0_49_rxode2parse[] = {&d_shift_89_rxode2parse,NULL}; -unsigned char d_scanner_0_49_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_50_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 69, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 71, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_50_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_51_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 70, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 72, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_51_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_52_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, +23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_51_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 22, -0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_52_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 0, 0, 0, 23, +0, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_51_rxode2parse[] = {&d_shift_77_rxode2parse,NULL}; - -unsigned char d_scanner_0_52_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 71, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, -}; +D_Shift * d_shift_0_52_rxode2parse[] = {&d_shift_77_rxode2parse,NULL}; unsigned char d_scanner_0_53_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 72, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 73, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_54_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -73, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 3, 3, 74, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_55_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 74, 3, 3, +0, 3, 3, 3, 3, 3, 75, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_56_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 75, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +76, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_57_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 76, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 77, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_58_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 77, 3, +0, 3, 78, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_59_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 78, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 79, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_60_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 79, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 80, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_61_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 80, 3, 3, 3, +0, 3, 3, 3, 3, 81, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; unsigned char d_scanner_0_62_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 81, 3, +0, 3, 3, 3, 3, 82, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_63_rxode2parse[] = {&d_shift_101_rxode2parse,NULL}; +unsigned char d_scanner_0_63_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 83, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +}; -D_Shift * d_shift_0_64_rxode2parse[] = {&d_shift_99_rxode2parse,NULL}; +unsigned char d_scanner_0_64_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 84, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +}; + +D_Shift * d_shift_0_65_rxode2parse[] = {&d_shift_120_rxode2parse,NULL}; + +D_Shift * d_shift_0_66_rxode2parse[] = {&d_shift_118_rxode2parse,NULL}; -unsigned char d_accepts_diff_0_65_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_67_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, -20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_65_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, -20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 20, -0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, -20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_67_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 21, +0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_65_rxode2parse[] = {&d_shift_76_rxode2parse,NULL}; +D_Shift * d_shift_0_67_rxode2parse[] = {&d_shift_76_rxode2parse,NULL}; -unsigned char d_scanner_0_66_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_68_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 82, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 85, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_67_rxode2parse[] = {&d_shift_48_rxode2parse,NULL}; +D_Shift * d_shift_0_69_rxode2parse[] = {&d_shift_48_rxode2parse,NULL}; -unsigned char d_accepts_diff_0_68_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_70_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, -9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_68_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, -9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, -0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, -9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_70_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 10, +0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_68_rxode2parse[] = {&d_shift_35_rxode2parse,NULL}; +D_Shift * d_shift_0_70_rxode2parse[] = {&d_shift_35_rxode2parse,NULL}; -unsigned char d_scanner_0_69_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_71_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 83, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 86, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_70_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_72_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 87, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +}; + +unsigned char d_scanner_0_73_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 84, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 88, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_71_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_74_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_71_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_74_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 17, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_71_rxode2parse[] = {&d_shift_22_rxode2parse,NULL}; +D_Shift * d_shift_0_74_rxode2parse[] = {&d_shift_22_rxode2parse,NULL}; -unsigned char d_scanner_0_72_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_75_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 85, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 89, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_73_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_76_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 86, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 90, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_74_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_77_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_74_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 21, -0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_77_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 22, +0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_74_rxode2parse[] = {&d_shift_24_rxode2parse,NULL}; +D_Shift * d_shift_0_77_rxode2parse[] = {&d_shift_24_rxode2parse,NULL}; -unsigned char d_scanner_0_75_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_78_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 87, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 91, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_76_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_79_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 88, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 3, 92, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_77_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_80_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_77_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_80_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_77_rxode2parse[] = {&d_shift_83_rxode2parse,NULL}; +D_Shift * d_shift_0_80_rxode2parse[] = {&d_shift_83_rxode2parse,NULL}; -unsigned char d_scanner_0_78_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_81_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -89, 3, 3, 3, 90, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +93, 3, 3, 3, 94, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_79_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_82_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 91, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 95, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_80_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_83_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 92, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 3, 96, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_81_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_84_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_81_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_84_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_81_rxode2parse[] = {&d_shift_11_rxode2parse,NULL}; +D_Shift * d_shift_0_84_rxode2parse[] = {&d_shift_11_rxode2parse,NULL}; -unsigned char d_scanner_0_82_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_85_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 93, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 97, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_83_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_86_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 94, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 98, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_84_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_87_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 95, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 99, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +}; + +unsigned char d_scanner_0_88_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 100, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_85_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_89_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, -12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_85_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 12, -0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_89_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 15, +0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_85_rxode2parse[] = {&d_shift_103_rxode2parse,NULL}; +D_Shift * d_shift_0_89_rxode2parse[] = {&d_shift_122_rxode2parse,NULL}; -unsigned char d_accepts_diff_0_86_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_90_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_86_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_90_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 96, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 101, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_86_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_90_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_86_rxode2parse[] = {&d_shift_18_rxode2parse,NULL}; +D_Shift * d_shift_0_90_rxode2parse[] = {&d_shift_18_rxode2parse,NULL}; -unsigned char d_accepts_diff_0_87_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_91_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_87_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_91_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 97, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 102, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_87_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_91_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_87_rxode2parse[] = {&d_shift_34_rxode2parse,NULL}; +D_Shift * d_shift_0_91_rxode2parse[] = {&d_shift_34_rxode2parse,NULL}; -unsigned char d_scanner_0_88_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_92_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 98, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 103, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_89_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_93_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 99, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 104, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_0_91_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_95_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 100, 3, 3, 3, 3, 3, 3, 3, 3, 3, +0, 3, 3, 3, 3, 3, 105, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_92_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_96_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_92_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_96_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_92_rxode2parse[] = {&d_shift_2_rxode2parse,NULL}; +D_Shift * d_shift_0_96_rxode2parse[] = {&d_shift_2_rxode2parse,NULL}; -unsigned char d_accepts_diff_0_93_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_97_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, -19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_93_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, -19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 19, -0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, -19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_97_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_93_rxode2parse[] = {&d_shift_23_rxode2parse,NULL}; +D_Shift * d_shift_0_97_rxode2parse[] = {&d_shift_102_rxode2parse,NULL}; -unsigned char d_scanner_0_94_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_98_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, 0, +}; + +unsigned char d_accepts_diff_0_98_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 20, +0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, +}; + +D_Shift * d_shift_0_98_rxode2parse[] = {&d_shift_23_rxode2parse,NULL}; + +unsigned char d_scanner_0_99_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 101, 3, +0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 106, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_95_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_100_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_96_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_101_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_96_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_101_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_96_rxode2parse[] = {&d_shift_32_rxode2parse,NULL}; +D_Shift * d_shift_0_101_rxode2parse[] = {&d_shift_32_rxode2parse,NULL}; -unsigned char d_accepts_diff_0_97_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_102_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, -10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_97_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, -10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 10, -0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, -10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_102_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 11, +0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_97_rxode2parse[] = {&d_shift_12_rxode2parse,NULL}; +D_Shift * d_shift_0_102_rxode2parse[] = {&d_shift_12_rxode2parse,NULL}; -unsigned char d_accepts_diff_0_99_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_104_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_99_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_104_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_99_rxode2parse[] = {&d_shift_33_rxode2parse,NULL}; +D_Shift * d_shift_0_104_rxode2parse[] = {&d_shift_33_rxode2parse,NULL}; -unsigned char d_scanner_0_100_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_0_105_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 102, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, +3, 3, 3, 3, 107, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_101_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_0_106_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_0_101_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 0, 0, 0, 23, -0, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 0, 0, 0, 0, +unsigned char d_accepts_diff_0_106_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 24, +0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_0_101_rxode2parse[] = {&d_shift_25_rxode2parse,NULL}; +D_Shift * d_shift_0_106_rxode2parse[] = {&d_shift_25_rxode2parse,NULL}; D_Shift * d_accepts_diff_3_0_rxode2parse[] = {0}; D_Shift ** d_accepts_diff_3_rxode2parse[] = { @@ -1408,79 +1485,79 @@ unsigned char d_scanner_3_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { D_Shift * d_shift_3_1_rxode2parse[] = {&d_shift_3_rxode2parse,NULL}; -D_Shift * d_accepts_diff_25_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_25_rxode2parse[] = { -d_accepts_diff_25_0_rxode2parse +D_Shift * d_accepts_diff_26_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_26_rxode2parse[] = { +d_accepts_diff_26_0_rxode2parse }; -unsigned char d_scanner_25_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_26_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, }; -D_Shift * d_shift_25_1_rxode2parse[] = {&d_shift_41_rxode2parse,NULL}; +D_Shift * d_shift_26_1_rxode2parse[] = {&d_shift_41_rxode2parse,NULL}; -D_Shift * d_accepts_diff_58_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_58_rxode2parse[] = { -d_accepts_diff_58_0_rxode2parse +D_Shift * d_accepts_diff_59_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_59_rxode2parse[] = { +d_accepts_diff_59_0_rxode2parse }; -unsigned char d_scanner_58_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_59_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, }; -D_Shift * d_shift_58_1_rxode2parse[] = {&d_shift_95_rxode2parse,NULL}; +D_Shift * d_shift_59_1_rxode2parse[] = {&d_shift_95_rxode2parse,NULL}; -D_Shift * d_accepts_diff_63_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_63_rxode2parse[] = { -d_accepts_diff_63_0_rxode2parse +D_Shift * d_accepts_diff_67_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_67_rxode2parse[] = { +d_accepts_diff_67_0_rxode2parse }; -unsigned char d_scanner_63_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_67_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 0, 0, }; -unsigned char d_scanner_63_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_67_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, }; -unsigned char d_scanner_63_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_67_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_63_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_67_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_63_4_rxode2parse[] = {&d_shift_53_rxode2parse,NULL}; +D_Shift * d_shift_67_4_rxode2parse[] = {&d_shift_53_rxode2parse,NULL}; -unsigned char d_scanner_63_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_67_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_63_6_rxode2parse[] = {&d_shift_42_rxode2parse,NULL}; +D_Shift * d_shift_67_6_rxode2parse[] = {&d_shift_42_rxode2parse,NULL}; -D_Shift * d_shift_63_7_rxode2parse[] = {&d_shift_40_rxode2parse,NULL}; +D_Shift * d_shift_67_7_rxode2parse[] = {&d_shift_40_rxode2parse,NULL}; D_Shift * d_accepts_diff_68_0_rxode2parse[] = {0}; D_Shift ** d_accepts_diff_68_rxode2parse[] = { @@ -1488,1986 +1565,2100 @@ d_accepts_diff_68_0_rxode2parse }; unsigned char d_scanner_68_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, +}; + +unsigned char d_scanner_68_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, +}; + +unsigned char d_scanner_68_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +D_Shift * d_accepts_diff_75_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_75_rxode2parse[] = { +d_accepts_diff_75_0_rxode2parse +}; + +unsigned char d_scanner_75_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_68_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_75_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_68_1_rxode2parse[] = {&d_shift_203_rxode2parse,NULL}; +D_Shift * d_shift_75_1_rxode2parse[] = {&d_shift_223_rxode2parse,NULL}; -D_Shift * d_shift_68_2_rxode2parse[] = {&d_shift_204_rxode2parse,NULL}; +D_Shift * d_shift_75_2_rxode2parse[] = {&d_shift_224_rxode2parse,NULL}; -D_Shift * d_accepts_diff_70_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_70_rxode2parse[] = { -d_accepts_diff_70_0_rxode2parse +D_Shift * d_accepts_diff_77_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_77_rxode2parse[] = { +d_accepts_diff_77_0_rxode2parse }; -D_Shift * d_shift_70_1_rxode2parse[] = {&d_shift_1_rxode2parse,NULL}; +D_Shift * d_shift_77_1_rxode2parse[] = {&d_shift_1_rxode2parse,NULL}; -D_Shift * d_accepts_diff_71_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_71_1_rxode2parse[] = {&d_shift_69_rxode2parse,0}; -D_Shift * d_accepts_diff_71_2_rxode2parse[] = {&d_shift_83_rxode2parse,0}; -D_Shift * d_accepts_diff_71_3_rxode2parse[] = {&d_shift_89_rxode2parse,0}; -D_Shift * d_accepts_diff_71_4_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift * d_accepts_diff_71_5_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift * d_accepts_diff_71_6_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift ** d_accepts_diff_71_rxode2parse[] = { -d_accepts_diff_71_0_rxode2parse, -d_accepts_diff_71_1_rxode2parse, -d_accepts_diff_71_2_rxode2parse, -d_accepts_diff_71_3_rxode2parse, -d_accepts_diff_71_4_rxode2parse, -d_accepts_diff_71_5_rxode2parse, -d_accepts_diff_71_6_rxode2parse +D_Shift * d_accepts_diff_78_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_78_1_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift * d_accepts_diff_78_2_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_78_3_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift * d_accepts_diff_78_4_rxode2parse[] = {&d_shift_69_rxode2parse,0}; +D_Shift * d_accepts_diff_78_5_rxode2parse[] = {&d_shift_83_rxode2parse,0}; +D_Shift * d_accepts_diff_78_6_rxode2parse[] = {&d_shift_89_rxode2parse,0}; +D_Shift ** d_accepts_diff_78_rxode2parse[] = { +d_accepts_diff_78_0_rxode2parse, +d_accepts_diff_78_1_rxode2parse, +d_accepts_diff_78_2_rxode2parse, +d_accepts_diff_78_3_rxode2parse, +d_accepts_diff_78_4_rxode2parse, +d_accepts_diff_78_5_rxode2parse, +d_accepts_diff_78_6_rxode2parse }; -unsigned char d_scanner_71_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_78_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 2, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 6, 7, 0, +0, 2, 3, 0, 0, 0, 0, 4, 5, 0, 0, 6, 0, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, -0, 10, 8, 8, 11, 8, 12, 8, 8, 8, 8, 8, 13, 8, 8, 8, -8, 8, 14, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, +0, 11, 9, 9, 12, 9, 13, 9, 9, 9, 9, 9, 14, 9, 9, 9, +9, 9, 15, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_71_1_rxode2parse[] = {&d_shift_115_rxode2parse,NULL}; +D_Shift * d_shift_78_1_rxode2parse[] = {&d_shift_134_rxode2parse,NULL}; -unsigned char d_scanner_71_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 16, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +unsigned char d_scanner_78_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, }; -unsigned char d_scanner_71_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 17, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +unsigned char d_scanner_78_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 18, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, }; -unsigned char d_scanner_71_2_2_rxode2parse[SCANNER_BLOCK_SIZE] = { -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +unsigned char d_scanner_78_2_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, }; -D_Shift * d_shift_71_4_rxode2parse[] = {&d_shift_54_rxode2parse,NULL}; +unsigned char d_scanner_78_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 20, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +}; -D_Shift * d_shift_71_5_rxode2parse[] = {&d_shift_39_rxode2parse,NULL}; +unsigned char d_scanner_78_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 21, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +}; + +unsigned char d_scanner_78_3_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +}; -unsigned char d_scanner_71_6_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +D_Shift * d_shift_78_5_rxode2parse[] = {&d_shift_54_rxode2parse,NULL}; + +D_Shift * d_shift_78_6_rxode2parse[] = {&d_shift_39_rxode2parse,NULL}; + +unsigned char d_scanner_78_7_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, -18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 18, -0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, -18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 22, +0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_7_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_78_8_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 23, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, +}; + +unsigned char d_scanner_78_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 24, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, +}; + +unsigned char d_scanner_78_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 25, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, +}; + +unsigned char d_scanner_78_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 26, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 20, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, -}; +D_Shift * d_shift_78_16_rxode2parse[] = {&d_shift_214_rxode2parse,NULL}; -unsigned char d_scanner_71_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 21, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_17_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, }; -unsigned char d_scanner_71_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 22, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, }; -D_Shift * d_shift_71_15_rxode2parse[] = {&d_shift_195_rxode2parse,NULL}; +D_Shift * d_shift_78_19_rxode2parse[] = {&d_shift_215_rxode2parse,NULL}; -unsigned char d_scanner_71_16_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, +unsigned char d_scanner_78_20_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, }; -unsigned char d_scanner_71_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, +unsigned char d_scanner_78_20_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, }; -unsigned char d_scanner_71_17_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_78_21_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, -18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 24, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_22_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 29, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_19_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 25, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 30, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_20_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 8, 8, 26, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 31, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_21_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 27, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_25_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 32, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 8, 8, 28, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_28_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 9, 9, 33, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_71_26_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, -0, 8, 8, 8, 8, 29, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, -8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +unsigned char d_scanner_78_31_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, +0, 9, 9, 9, 9, 34, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, +9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_73_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_73_rxode2parse[] = { -d_accepts_diff_73_0_rxode2parse +D_Shift * d_accepts_diff_80_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_80_rxode2parse[] = { +d_accepts_diff_80_0_rxode2parse }; -unsigned char d_scanner_73_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_80_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_73_1_rxode2parse[] = {&d_shift_6_rxode2parse,NULL}; +D_Shift * d_shift_80_1_rxode2parse[] = {&d_shift_6_rxode2parse,NULL}; -D_Shift * d_accepts_diff_74_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_74_1_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift * d_accepts_diff_74_2_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift * d_accepts_diff_74_3_rxode2parse[] = {&d_shift_69_rxode2parse,0}; -D_Shift * d_accepts_diff_74_4_rxode2parse[] = {&d_shift_83_rxode2parse,0}; -D_Shift * d_accepts_diff_74_5_rxode2parse[] = {&d_shift_89_rxode2parse,0}; -D_Shift * d_accepts_diff_74_6_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift ** d_accepts_diff_74_rxode2parse[] = { -d_accepts_diff_74_0_rxode2parse, -d_accepts_diff_74_1_rxode2parse, -d_accepts_diff_74_2_rxode2parse, -d_accepts_diff_74_3_rxode2parse, -d_accepts_diff_74_4_rxode2parse, -d_accepts_diff_74_5_rxode2parse, -d_accepts_diff_74_6_rxode2parse +D_Shift * d_accepts_diff_81_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_81_1_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift * d_accepts_diff_81_2_rxode2parse[] = {&d_shift_89_rxode2parse,0}; +D_Shift * d_accepts_diff_81_3_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_81_4_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift * d_accepts_diff_81_5_rxode2parse[] = {&d_shift_69_rxode2parse,0}; +D_Shift * d_accepts_diff_81_6_rxode2parse[] = {&d_shift_83_rxode2parse,0}; +D_Shift ** d_accepts_diff_81_rxode2parse[] = { +d_accepts_diff_81_0_rxode2parse, +d_accepts_diff_81_1_rxode2parse, +d_accepts_diff_81_2_rxode2parse, +d_accepts_diff_81_3_rxode2parse, +d_accepts_diff_81_4_rxode2parse, +d_accepts_diff_81_5_rxode2parse, +d_accepts_diff_81_6_rxode2parse }; -unsigned char d_scanner_74_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 5, 3, 3, 6, 3, 7, 3, 3, 3, 3, 3, 8, 3, 3, 3, 3, 3, 9, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_4_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_4_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 12, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 13, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 14, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_9_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_9_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 15, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 16, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 17, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 18, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 19, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_74_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_81_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 20, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_75_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_75_1_rxode2parse[] = {&d_shift_89_rxode2parse,0}; -D_Shift * d_accepts_diff_75_2_rxode2parse[] = {&d_shift_174_rxode2parse,0}; -D_Shift * d_accepts_diff_75_3_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift * d_accepts_diff_75_4_rxode2parse[] = {&d_shift_69_rxode2parse,0}; -D_Shift * d_accepts_diff_75_5_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift * d_accepts_diff_75_6_rxode2parse[] = {&d_shift_169_rxode2parse,0}; -D_Shift * d_accepts_diff_75_7_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift * d_accepts_diff_75_8_rxode2parse[] = {&d_shift_170_rxode2parse,0}; -D_Shift * d_accepts_diff_75_9_rxode2parse[] = {&d_shift_83_rxode2parse,0}; -D_Shift * d_accepts_diff_75_10_rxode2parse[] = {&d_shift_173_rxode2parse,0}; -D_Shift ** d_accepts_diff_75_rxode2parse[] = { -d_accepts_diff_75_0_rxode2parse, -d_accepts_diff_75_1_rxode2parse, -d_accepts_diff_75_2_rxode2parse, -d_accepts_diff_75_3_rxode2parse, -d_accepts_diff_75_4_rxode2parse, -d_accepts_diff_75_5_rxode2parse, -d_accepts_diff_75_6_rxode2parse, -d_accepts_diff_75_7_rxode2parse, -d_accepts_diff_75_8_rxode2parse, -d_accepts_diff_75_9_rxode2parse, -d_accepts_diff_75_10_rxode2parse -}; - -unsigned char d_scanner_75_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +D_Shift * d_accepts_diff_82_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_82_1_rxode2parse[] = {&d_shift_193_rxode2parse,0}; +D_Shift * d_accepts_diff_82_2_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_82_3_rxode2parse[] = {&d_shift_69_rxode2parse,0}; +D_Shift * d_accepts_diff_82_4_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift * d_accepts_diff_82_5_rxode2parse[] = {&d_shift_188_rxode2parse,0}; +D_Shift * d_accepts_diff_82_6_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift * d_accepts_diff_82_7_rxode2parse[] = {&d_shift_189_rxode2parse,0}; +D_Shift * d_accepts_diff_82_8_rxode2parse[] = {&d_shift_83_rxode2parse,0}; +D_Shift * d_accepts_diff_82_9_rxode2parse[] = {&d_shift_192_rxode2parse,0}; +D_Shift * d_accepts_diff_82_10_rxode2parse[] = {&d_shift_89_rxode2parse,0}; +D_Shift ** d_accepts_diff_82_rxode2parse[] = { +d_accepts_diff_82_0_rxode2parse, +d_accepts_diff_82_1_rxode2parse, +d_accepts_diff_82_2_rxode2parse, +d_accepts_diff_82_3_rxode2parse, +d_accepts_diff_82_4_rxode2parse, +d_accepts_diff_82_5_rxode2parse, +d_accepts_diff_82_6_rxode2parse, +d_accepts_diff_82_7_rxode2parse, +d_accepts_diff_82_8_rxode2parse, +d_accepts_diff_82_9_rxode2parse, +d_accepts_diff_82_10_rxode2parse +}; + +unsigned char d_scanner_82_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 4, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 7, 3, 3, 8, 9, 10, 3, 3, 3, 3, 3, 11, 3, 3, 3, 3, 3, 12, 3, 13, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 15, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 16, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 17, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 18, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 19, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 20, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 21, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 22, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_13_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_13_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 23, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 24, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 25, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 26, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 27, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_19_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_19_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 28, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_20_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_20_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 29, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_21_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_21_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 30, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_75_22_rxode2parse[] = {&d_shift_173_rxode2parse,NULL}; +D_Shift * d_shift_82_22_rxode2parse[] = {&d_shift_192_rxode2parse,NULL}; -unsigned char d_scanner_75_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 31, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 32, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_75_26_rxode2parse[] = {&d_shift_174_rxode2parse,NULL}; +D_Shift * d_shift_82_26_rxode2parse[] = {&d_shift_193_rxode2parse,NULL}; -unsigned char d_scanner_75_28_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_28_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 33, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_29_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_29_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 34, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_30_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_30_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 35, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_75_33_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_82_33_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0, 36, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_75_34_rxode2parse[] = {&d_shift_169_rxode2parse,NULL}; +D_Shift * d_shift_82_34_rxode2parse[] = {&d_shift_188_rxode2parse,NULL}; -D_Shift * d_shift_75_35_rxode2parse[] = {&d_shift_170_rxode2parse,NULL}; +D_Shift * d_shift_82_35_rxode2parse[] = {&d_shift_189_rxode2parse,NULL}; -D_Shift * d_accepts_diff_76_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_76_rxode2parse[] = { -d_accepts_diff_76_0_rxode2parse +D_Shift * d_accepts_diff_83_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_83_rxode2parse[] = { +d_accepts_diff_83_0_rxode2parse }; -unsigned char d_scanner_76_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_83_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_92_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_92_rxode2parse[] = { -d_accepts_diff_92_0_rxode2parse +D_Shift * d_accepts_diff_100_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_100_rxode2parse[] = { +d_accepts_diff_100_0_rxode2parse }; -unsigned char d_scanner_92_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_100_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_92_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +unsigned char d_scanner_100_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; -unsigned char d_scanner_92_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +unsigned char d_scanner_100_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; -unsigned char d_scanner_92_1_2_rxode2parse[SCANNER_BLOCK_SIZE] = { -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +unsigned char d_scanner_100_1_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; -unsigned char d_scanner_92_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, +unsigned char d_scanner_100_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, }; -unsigned char d_scanner_92_4_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, +unsigned char d_scanner_100_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 9, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, }; -D_Shift * d_accepts_diff_111_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_111_rxode2parse[] = { -d_accepts_diff_111_0_rxode2parse +unsigned char d_scanner_100_2_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, }; -unsigned char d_scanner_111_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, +unsigned char d_scanner_100_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +}; + +unsigned char d_scanner_100_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, +}; + +unsigned char d_scanner_100_8_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +}; + +unsigned char d_scanner_100_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +}; + +D_Shift * d_accepts_diff_122_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_122_rxode2parse[] = { +d_accepts_diff_122_0_rxode2parse }; -unsigned char d_scanner_111_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_122_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_118_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_118_rxode2parse[] = { -d_accepts_diff_118_0_rxode2parse +D_Shift * d_accepts_diff_133_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_133_rxode2parse[] = { +d_accepts_diff_133_0_rxode2parse }; -unsigned char d_scanner_118_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_133_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; -unsigned char d_scanner_118_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_133_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; -D_Shift * d_shift_118_0_rxode2parse[] = {&d_shift_205_rxode2parse,NULL}; +D_Shift * d_shift_133_0_rxode2parse[] = {&d_shift_225_rxode2parse,NULL}; -D_Shift * d_accepts_diff_122_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_122_1_rxode2parse[] = {&d_shift_69_rxode2parse,0}; -D_Shift * d_accepts_diff_122_2_rxode2parse[] = {&d_shift_89_rxode2parse,0}; -D_Shift * d_accepts_diff_122_3_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift * d_accepts_diff_122_4_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift * d_accepts_diff_122_5_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift * d_accepts_diff_122_6_rxode2parse[] = {&d_shift_83_rxode2parse,0}; -D_Shift ** d_accepts_diff_122_rxode2parse[] = { -d_accepts_diff_122_0_rxode2parse, -d_accepts_diff_122_1_rxode2parse, -d_accepts_diff_122_2_rxode2parse, -d_accepts_diff_122_3_rxode2parse, -d_accepts_diff_122_4_rxode2parse, -d_accepts_diff_122_5_rxode2parse, -d_accepts_diff_122_6_rxode2parse +D_Shift * d_accepts_diff_137_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_137_1_rxode2parse[] = {&d_shift_89_rxode2parse,0}; +D_Shift * d_accepts_diff_137_2_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift * d_accepts_diff_137_3_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift * d_accepts_diff_137_4_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_137_5_rxode2parse[] = {&d_shift_83_rxode2parse,0}; +D_Shift * d_accepts_diff_137_6_rxode2parse[] = {&d_shift_69_rxode2parse,0}; +D_Shift ** d_accepts_diff_137_rxode2parse[] = { +d_accepts_diff_137_0_rxode2parse, +d_accepts_diff_137_1_rxode2parse, +d_accepts_diff_137_2_rxode2parse, +d_accepts_diff_137_3_rxode2parse, +d_accepts_diff_137_4_rxode2parse, +d_accepts_diff_137_5_rxode2parse, +d_accepts_diff_137_6_rxode2parse }; -unsigned char d_scanner_122_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_137_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 6, 0, +0, 2, 3, 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, -0, 9, 7, 7, 10, 7, 11, 7, 7, 7, 7, 7, 12, 7, 7, 7, -7, 7, 13, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, +0, 10, 8, 8, 11, 8, 12, 8, 8, 8, 8, 8, 13, 8, 8, 8, +8, 8, 14, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 15, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +unsigned char d_scanner_137_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 16, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, }; -unsigned char d_scanner_122_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 16, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +unsigned char d_scanner_137_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 17, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, }; -unsigned char d_scanner_122_2_2_rxode2parse[SCANNER_BLOCK_SIZE] = { -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +unsigned char d_scanner_137_2_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, }; -unsigned char d_scanner_122_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 19, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, }; -unsigned char d_scanner_122_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, -17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 17, -0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, -17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 20, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +}; + +unsigned char d_scanner_137_3_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, }; -unsigned char d_scanner_122_6_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_137_6_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_7_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 18, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 22, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 20, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 23, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 21, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 24, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_15_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, +unsigned char d_scanner_137_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 25, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, +unsigned char d_scanner_137_16_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, }; -unsigned char d_scanner_122_16_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, -17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, }; -unsigned char d_scanner_122_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 23, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_21_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 28, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 24, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_22_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 29, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_19_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 7, 7, 25, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 8, 8, 30, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_20_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 26, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 31, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_22_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 7, 7, 27, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_27_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 8, 8, 32, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_122_25_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, -0, 7, 7, 7, 7, 28, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, -7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +unsigned char d_scanner_137_30_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 8, +0, 8, 8, 8, 8, 33, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_131_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_131_1_rxode2parse[] = {&d_shift_69_rxode2parse,0}; -D_Shift * d_accepts_diff_131_2_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift * d_accepts_diff_131_3_rxode2parse[] = {&d_shift_83_rxode2parse,0}; -D_Shift * d_accepts_diff_131_4_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift * d_accepts_diff_131_5_rxode2parse[] = {&d_shift_89_rxode2parse,0}; -D_Shift * d_accepts_diff_131_6_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift ** d_accepts_diff_131_rxode2parse[] = { -d_accepts_diff_131_0_rxode2parse, -d_accepts_diff_131_1_rxode2parse, -d_accepts_diff_131_2_rxode2parse, -d_accepts_diff_131_3_rxode2parse, -d_accepts_diff_131_4_rxode2parse, -d_accepts_diff_131_5_rxode2parse, -d_accepts_diff_131_6_rxode2parse +D_Shift * d_accepts_diff_146_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_146_1_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift * d_accepts_diff_146_2_rxode2parse[] = {&d_shift_83_rxode2parse,0}; +D_Shift * d_accepts_diff_146_3_rxode2parse[] = {&d_shift_69_rxode2parse,0}; +D_Shift * d_accepts_diff_146_4_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_146_5_rxode2parse[] = {&d_shift_89_rxode2parse,0}; +D_Shift * d_accepts_diff_146_6_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift ** d_accepts_diff_146_rxode2parse[] = { +d_accepts_diff_146_0_rxode2parse, +d_accepts_diff_146_1_rxode2parse, +d_accepts_diff_146_2_rxode2parse, +d_accepts_diff_146_3_rxode2parse, +d_accepts_diff_146_4_rxode2parse, +d_accepts_diff_146_5_rxode2parse, +d_accepts_diff_146_6_rxode2parse }; -unsigned char d_scanner_131_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 6, 4, 4, 7, 4, 8, 4, 4, 4, 4, 4, 9, 4, 4, 4, 4, 4, 10, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 11, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 12, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 13, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 14, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 16, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 17, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 18, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 19, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 4, 4, 20, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_131_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_146_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 4, 4, 4, 21, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_133_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_133_rxode2parse[] = { -d_accepts_diff_133_0_rxode2parse +D_Shift * d_accepts_diff_151_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_151_rxode2parse[] = { +d_accepts_diff_151_0_rxode2parse }; -unsigned char d_scanner_133_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_151_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_133_1_rxode2parse[] = {&d_shift_4_rxode2parse,NULL}; - -D_Shift * d_accepts_diff_144_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_144_1_rxode2parse[] = {&d_shift_69_rxode2parse,0}; -D_Shift * d_accepts_diff_144_2_rxode2parse[] = {&d_shift_198_rxode2parse,0}; -D_Shift * d_accepts_diff_144_3_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift * d_accepts_diff_144_4_rxode2parse[] = {&d_shift_83_rxode2parse,0}; -D_Shift * d_accepts_diff_144_5_rxode2parse[] = {&d_shift_89_rxode2parse,0}; -D_Shift * d_accepts_diff_144_6_rxode2parse[] = {&d_shift_169_rxode2parse,0}; -D_Shift * d_accepts_diff_144_7_rxode2parse[] = {&d_shift_170_rxode2parse,0}; -D_Shift * d_accepts_diff_144_8_rxode2parse[] = {&d_shift_59_rxode2parse,0}; -D_Shift * d_accepts_diff_144_9_rxode2parse[] = {&d_shift_173_rxode2parse,0}; -D_Shift * d_accepts_diff_144_10_rxode2parse[] = {&d_shift_174_rxode2parse,0}; -D_Shift * d_accepts_diff_144_11_rxode2parse[] = {&d_shift_2_rxode2parse,0}; -D_Shift * d_accepts_diff_144_12_rxode2parse[] = {&d_shift_194_rxode2parse,0}; -D_Shift * d_accepts_diff_144_13_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift * d_accepts_diff_144_14_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift ** d_accepts_diff_144_rxode2parse[] = { -d_accepts_diff_144_0_rxode2parse, -d_accepts_diff_144_1_rxode2parse, -d_accepts_diff_144_2_rxode2parse, -d_accepts_diff_144_3_rxode2parse, -d_accepts_diff_144_4_rxode2parse, -d_accepts_diff_144_5_rxode2parse, -d_accepts_diff_144_6_rxode2parse, -d_accepts_diff_144_7_rxode2parse, -d_accepts_diff_144_8_rxode2parse, -d_accepts_diff_144_9_rxode2parse, -d_accepts_diff_144_10_rxode2parse, -d_accepts_diff_144_11_rxode2parse, -d_accepts_diff_144_12_rxode2parse, -d_accepts_diff_144_13_rxode2parse, -d_accepts_diff_144_14_rxode2parse -}; - -unsigned char d_scanner_144_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +D_Shift * d_shift_151_1_rxode2parse[] = {&d_shift_4_rxode2parse,NULL}; + +D_Shift * d_accepts_diff_162_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_162_1_rxode2parse[] = {&d_shift_69_rxode2parse,0}; +D_Shift * d_accepts_diff_162_2_rxode2parse[] = {&d_shift_218_rxode2parse,0}; +D_Shift * d_accepts_diff_162_3_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift * d_accepts_diff_162_4_rxode2parse[] = {&d_shift_83_rxode2parse,0}; +D_Shift * d_accepts_diff_162_5_rxode2parse[] = {&d_shift_89_rxode2parse,0}; +D_Shift * d_accepts_diff_162_6_rxode2parse[] = {&d_shift_188_rxode2parse,0}; +D_Shift * d_accepts_diff_162_7_rxode2parse[] = {&d_shift_189_rxode2parse,0}; +D_Shift * d_accepts_diff_162_8_rxode2parse[] = {&d_shift_59_rxode2parse,0}; +D_Shift * d_accepts_diff_162_9_rxode2parse[] = {&d_shift_192_rxode2parse,0}; +D_Shift * d_accepts_diff_162_10_rxode2parse[] = {&d_shift_193_rxode2parse,0}; +D_Shift * d_accepts_diff_162_11_rxode2parse[] = {&d_shift_2_rxode2parse,0}; +D_Shift * d_accepts_diff_162_12_rxode2parse[] = {&d_shift_213_rxode2parse,0}; +D_Shift * d_accepts_diff_162_13_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_162_14_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift ** d_accepts_diff_162_rxode2parse[] = { +d_accepts_diff_162_0_rxode2parse, +d_accepts_diff_162_1_rxode2parse, +d_accepts_diff_162_2_rxode2parse, +d_accepts_diff_162_3_rxode2parse, +d_accepts_diff_162_4_rxode2parse, +d_accepts_diff_162_5_rxode2parse, +d_accepts_diff_162_6_rxode2parse, +d_accepts_diff_162_7_rxode2parse, +d_accepts_diff_162_8_rxode2parse, +d_accepts_diff_162_9_rxode2parse, +d_accepts_diff_162_10_rxode2parse, +d_accepts_diff_162_11_rxode2parse, +d_accepts_diff_162_12_rxode2parse, +d_accepts_diff_162_13_rxode2parse, +d_accepts_diff_162_14_rxode2parse +}; + +unsigned char d_scanner_162_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 7, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 10, 6, 6, 11, 12, 13, 6, 6, 14, 6, 6, 15, 6, 6, 6, 6, 6, 16, 6, 17, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 20, 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_144_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_162_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_144_3_rxode2parse[] = {&d_shift_194_rxode2parse,NULL}; +D_Shift * d_shift_162_3_rxode2parse[] = {&d_shift_213_rxode2parse,NULL}; -unsigned char d_scanner_144_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_144_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_162_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_5_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 24, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 25, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 26, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 27, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_144_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_162_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 28, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 29, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 30, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_13_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 31, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 32, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 33, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 34, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_17_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_17_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_18_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_18_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_144_18_rxode2parse[] = {&d_shift_196_rxode2parse,NULL}; +D_Shift * d_shift_162_18_rxode2parse[] = {&d_shift_216_rxode2parse,NULL}; -unsigned char d_scanner_144_19_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_19_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_20_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_20_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_22_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_22_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 37, 0, 0, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 39, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 40, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_25_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_25_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 41, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_26_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_26_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_28_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_28_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 43, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_29_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_29_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 44, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_30_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_30_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 45, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_31_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_31_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 46, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_32_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_32_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 47, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_33_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_33_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 48, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_34_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_34_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 49, 0, 0, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_36_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_36_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_144_37_rxode2parse[] = {&d_shift_197_rxode2parse,NULL}; +D_Shift * d_shift_162_37_rxode2parse[] = {&d_shift_217_rxode2parse,NULL}; -unsigned char d_scanner_144_39_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_39_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 51, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_40_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_40_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 52, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_41_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_41_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_44_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_44_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 54, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_46_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_46_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 55, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_47_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_47_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 56, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_48_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_48_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_50_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_50_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 57, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_53_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_53_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 58, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_55_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_55_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 59, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_144_57_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_162_57_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 60, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_146_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_146_rxode2parse[] = { -d_accepts_diff_146_0_rxode2parse +D_Shift * d_accepts_diff_164_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_164_rxode2parse[] = { +d_accepts_diff_164_0_rxode2parse }; -unsigned char d_scanner_146_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_164_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, }; -unsigned char d_scanner_146_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_164_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, }; -unsigned char d_scanner_146_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_164_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, }; -D_Shift * d_shift_146_3_rxode2parse[] = {&d_shift_128_rxode2parse,NULL}; +D_Shift * d_shift_164_3_rxode2parse[] = {&d_shift_147_rxode2parse,NULL}; -D_Shift * d_shift_146_4_rxode2parse[] = {&d_shift_129_rxode2parse,NULL}; +D_Shift * d_shift_164_4_rxode2parse[] = {&d_shift_148_rxode2parse,NULL}; -D_Shift * d_accepts_diff_163_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_163_rxode2parse[] = { -d_accepts_diff_163_0_rxode2parse +D_Shift * d_accepts_diff_182_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_182_rxode2parse[] = { +d_accepts_diff_182_0_rxode2parse }; -unsigned char d_scanner_163_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_182_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_163_1_rxode2parse[] = {&d_shift_171_rxode2parse,NULL}; +D_Shift * d_shift_182_1_rxode2parse[] = {&d_shift_190_rxode2parse,NULL}; -D_Shift * d_accepts_diff_170_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_170_rxode2parse[] = { -d_accepts_diff_170_0_rxode2parse +D_Shift * d_accepts_diff_189_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_189_rxode2parse[] = { +d_accepts_diff_189_0_rxode2parse }; -unsigned char d_scanner_170_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_189_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_170_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_189_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_172_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_172_rxode2parse[] = { -d_accepts_diff_172_0_rxode2parse +D_Shift * d_accepts_diff_191_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_191_rxode2parse[] = { +d_accepts_diff_191_0_rxode2parse }; -unsigned char d_scanner_172_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_191_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_172_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_191_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_172_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_191_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_172_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_191_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_172_5_rxode2parse[] = {&d_shift_61_rxode2parse,NULL}; +D_Shift * d_shift_191_5_rxode2parse[] = {&d_shift_61_rxode2parse,NULL}; -D_Shift * d_accepts_diff_192_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_192_1_rxode2parse[] = {&d_shift_194_rxode2parse,0}; -D_Shift ** d_accepts_diff_192_rxode2parse[] = { -d_accepts_diff_192_0_rxode2parse, -d_accepts_diff_192_1_rxode2parse +D_Shift * d_accepts_diff_212_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_212_1_rxode2parse[] = {&d_shift_213_rxode2parse,0}; +D_Shift ** d_accepts_diff_212_rxode2parse[] = { +d_accepts_diff_212_0_rxode2parse, +d_accepts_diff_212_1_rxode2parse }; -unsigned char d_scanner_192_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_192_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_212_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_192_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_212_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_4_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_4_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_7_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_7_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 11, 0, 0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_8_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_8_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 13, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_10_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_192_12_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_212_12_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_198_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_198_1_rxode2parse[] = {&d_shift_70_rxode2parse,0}; -D_Shift * d_accepts_diff_198_2_rxode2parse[] = {&d_shift_89_rxode2parse,0}; -D_Shift * d_accepts_diff_198_3_rxode2parse[] = {&d_shift_77_rxode2parse,0}; -D_Shift * d_accepts_diff_198_4_rxode2parse[] = {&d_shift_76_rxode2parse,0}; -D_Shift * d_accepts_diff_198_5_rxode2parse[] = {&d_shift_69_rxode2parse,0}; -D_Shift * d_accepts_diff_198_6_rxode2parse[] = {&d_shift_83_rxode2parse,0}; -D_Shift ** d_accepts_diff_198_rxode2parse[] = { -d_accepts_diff_198_0_rxode2parse, -d_accepts_diff_198_1_rxode2parse, -d_accepts_diff_198_2_rxode2parse, -d_accepts_diff_198_3_rxode2parse, -d_accepts_diff_198_4_rxode2parse, -d_accepts_diff_198_5_rxode2parse, -d_accepts_diff_198_6_rxode2parse +D_Shift * d_accepts_diff_219_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_219_1_rxode2parse[] = {&d_shift_69_rxode2parse,0}; +D_Shift * d_accepts_diff_219_2_rxode2parse[] = {&d_shift_89_rxode2parse,0}; +D_Shift * d_accepts_diff_219_3_rxode2parse[] = {&d_shift_70_rxode2parse,0}; +D_Shift * d_accepts_diff_219_4_rxode2parse[] = {&d_shift_76_rxode2parse,0}; +D_Shift * d_accepts_diff_219_5_rxode2parse[] = {&d_shift_77_rxode2parse,0}; +D_Shift * d_accepts_diff_219_6_rxode2parse[] = {&d_shift_83_rxode2parse,0}; +D_Shift ** d_accepts_diff_219_rxode2parse[] = { +d_accepts_diff_219_0_rxode2parse, +d_accepts_diff_219_1_rxode2parse, +d_accepts_diff_219_2_rxode2parse, +d_accepts_diff_219_3_rxode2parse, +d_accepts_diff_219_4_rxode2parse, +d_accepts_diff_219_5_rxode2parse, +d_accepts_diff_219_6_rxode2parse }; -unsigned char d_scanner_198_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_219_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 5, 0, +0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, -0, 8, 6, 6, 9, 6, 10, 6, 6, 6, 6, 6, 11, 6, 6, 6, -6, 6, 12, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, +0, 9, 7, 7, 10, 7, 11, 7, 7, 7, 7, 7, 12, 7, 7, 7, +7, 7, 13, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +unsigned char d_scanner_219_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 15, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +}; + +unsigned char d_scanner_219_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 16, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +}; + +unsigned char d_scanner_219_1_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +}; + +unsigned char d_scanner_219_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 18, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, }; -unsigned char d_scanner_198_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 15, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +unsigned char d_scanner_219_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 19, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, }; -unsigned char d_scanner_198_1_2_rxode2parse[SCANNER_BLOCK_SIZE] = { -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +unsigned char d_scanner_219_2_2_rxode2parse[SCANNER_BLOCK_SIZE] = { +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, }; -unsigned char d_scanner_198_4_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_219_5_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_4_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, -16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 0, 0, 0, 16, -0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, -16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_6_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_7_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 17, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_6_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 18, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_8_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 21, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_10_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 19, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_9_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 22, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 20, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_11_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 23, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_14_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, +unsigned char d_scanner_219_12_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 24, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_14_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, +unsigned char d_scanner_219_15_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, }; -unsigned char d_scanner_198_15_0_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, -16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_15_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, }; -unsigned char d_scanner_198_16_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 22, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_20_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 27, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_17_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 23, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_21_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 28, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_18_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 6, 6, 6, 6, 6, 6, 24, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_22_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 7, 7, 29, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_19_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 25, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_23_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 30, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_21_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 6, 6, 6, 6, 6, 6, 26, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_26_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 7, 7, 31, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_198_24_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, -0, 6, 6, 6, 6, 27, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, -6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, +unsigned char d_scanner_219_29_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 7, +0, 7, 7, 7, 7, 32, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, +7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_206_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_206_1_rxode2parse[] = {&d_shift_110_rxode2parse,0}; -D_Shift ** d_accepts_diff_206_rxode2parse[] = { -d_accepts_diff_206_0_rxode2parse, -d_accepts_diff_206_1_rxode2parse +D_Shift * d_accepts_diff_227_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_227_1_rxode2parse[] = {&d_shift_129_rxode2parse,0}; +D_Shift ** d_accepts_diff_227_rxode2parse[] = { +d_accepts_diff_227_0_rxode2parse, +d_accepts_diff_227_1_rxode2parse }; -unsigned char d_scanner_206_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_227_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, }; -unsigned char d_scanner_206_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_227_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, }; -unsigned char d_accepts_diff_206_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_227_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, }; -D_Shift * d_shift_206_1_rxode2parse[] = {&d_shift_110_rxode2parse,NULL}; +D_Shift * d_shift_227_1_rxode2parse[] = {&d_shift_129_rxode2parse,NULL}; -D_Shift * d_shift_206_2_rxode2parse[] = {&d_shift_109_rxode2parse,NULL}; +D_Shift * d_shift_227_2_rxode2parse[] = {&d_shift_128_rxode2parse,NULL}; -D_Shift * d_accepts_diff_207_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_207_1_rxode2parse[] = {&d_shift_112_rxode2parse,0}; -D_Shift ** d_accepts_diff_207_rxode2parse[] = { -d_accepts_diff_207_0_rxode2parse, -d_accepts_diff_207_1_rxode2parse +D_Shift * d_accepts_diff_228_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_228_1_rxode2parse[] = {&d_shift_131_rxode2parse,0}; +D_Shift ** d_accepts_diff_228_rxode2parse[] = { +d_accepts_diff_228_0_rxode2parse, +d_accepts_diff_228_1_rxode2parse }; -unsigned char d_scanner_207_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_228_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_207_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_228_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_accepts_diff_207_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_228_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_207_1_rxode2parse[] = {&d_shift_112_rxode2parse,NULL}; +D_Shift * d_shift_228_1_rxode2parse[] = {&d_shift_131_rxode2parse,NULL}; -D_Shift * d_shift_207_2_rxode2parse[] = {&d_shift_111_rxode2parse,NULL}; +D_Shift * d_shift_228_2_rxode2parse[] = {&d_shift_130_rxode2parse,NULL}; -D_Shift * d_accepts_diff_209_0_rxode2parse[] = {0}; -D_Shift * d_accepts_diff_209_1_rxode2parse[] = {&d_shift_135_rxode2parse,0}; -D_Shift * d_accepts_diff_209_2_rxode2parse[] = {&d_shift_134_rxode2parse,0}; -D_Shift ** d_accepts_diff_209_rxode2parse[] = { -d_accepts_diff_209_0_rxode2parse, -d_accepts_diff_209_1_rxode2parse, -d_accepts_diff_209_2_rxode2parse +D_Shift * d_accepts_diff_230_0_rxode2parse[] = {0}; +D_Shift * d_accepts_diff_230_1_rxode2parse[] = {&d_shift_153_rxode2parse,0}; +D_Shift * d_accepts_diff_230_2_rxode2parse[] = {&d_shift_154_rxode2parse,0}; +D_Shift ** d_accepts_diff_230_rxode2parse[] = { +d_accepts_diff_230_0_rxode2parse, +d_accepts_diff_230_1_rxode2parse, +d_accepts_diff_230_2_rxode2parse }; -unsigned char d_scanner_209_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_230_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 0, }; -unsigned char d_scanner_209_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_230_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, }; -unsigned char d_accepts_diff_209_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_230_2_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_209_2_rxode2parse[] = {&d_shift_134_rxode2parse,NULL}; +D_Shift * d_shift_230_2_rxode2parse[] = {&d_shift_153_rxode2parse,NULL}; -unsigned char d_scanner_209_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_230_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, }; -unsigned char d_accepts_diff_209_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_accepts_diff_230_3_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, }; -D_Shift * d_shift_209_3_rxode2parse[] = {&d_shift_135_rxode2parse,NULL}; +D_Shift * d_shift_230_3_rxode2parse[] = {&d_shift_154_rxode2parse,NULL}; -D_Shift * d_shift_209_4_rxode2parse[] = {&d_shift_139_rxode2parse,NULL}; +D_Shift * d_shift_230_4_rxode2parse[] = {&d_shift_158_rxode2parse,NULL}; -D_Shift * d_shift_209_6_rxode2parse[] = {&d_shift_136_rxode2parse,NULL}; +D_Shift * d_shift_230_6_rxode2parse[] = {&d_shift_155_rxode2parse,NULL}; -D_Shift * d_shift_209_7_rxode2parse[] = {&d_shift_137_rxode2parse,NULL}; +D_Shift * d_shift_230_7_rxode2parse[] = {&d_shift_156_rxode2parse,NULL}; -D_Shift * d_accepts_diff_210_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_210_rxode2parse[] = { -d_accepts_diff_210_0_rxode2parse +D_Shift * d_accepts_diff_231_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_231_rxode2parse[] = { +d_accepts_diff_231_0_rxode2parse }; -unsigned char d_scanner_210_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_231_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_211_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_211_rxode2parse[] = { -d_accepts_diff_211_0_rxode2parse +D_Shift * d_accepts_diff_232_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_232_rxode2parse[] = { +d_accepts_diff_232_0_rxode2parse }; -unsigned char d_scanner_211_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_232_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_211_1_rxode2parse[] = {&d_shift_142_rxode2parse,NULL}; +D_Shift * d_shift_232_1_rxode2parse[] = {&d_shift_161_rxode2parse,NULL}; -D_Shift * d_shift_211_2_rxode2parse[] = {&d_shift_143_rxode2parse,NULL}; +D_Shift * d_shift_232_2_rxode2parse[] = {&d_shift_162_rxode2parse,NULL}; -D_Shift * d_accepts_diff_223_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_223_rxode2parse[] = { -d_accepts_diff_223_0_rxode2parse +D_Shift * d_accepts_diff_244_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_244_rxode2parse[] = { +d_accepts_diff_244_0_rxode2parse }; -unsigned char d_scanner_223_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_244_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_223_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_244_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_223_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_244_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_223_2_rxode2parse[] = {&d_shift_148_rxode2parse,NULL}; +D_Shift * d_shift_244_2_rxode2parse[] = {&d_shift_167_rxode2parse,NULL}; -D_Shift * d_shift_223_3_rxode2parse[] = {&d_shift_149_rxode2parse,NULL}; +D_Shift * d_shift_244_3_rxode2parse[] = {&d_shift_168_rxode2parse,NULL}; -D_Shift * d_accepts_diff_242_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_242_rxode2parse[] = { -d_accepts_diff_242_0_rxode2parse +D_Shift * d_accepts_diff_263_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_263_rxode2parse[] = { +d_accepts_diff_263_0_rxode2parse }; -unsigned char d_scanner_242_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_263_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_243_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_243_rxode2parse[] = { -d_accepts_diff_243_0_rxode2parse +D_Shift * d_accepts_diff_264_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_264_rxode2parse[] = { +d_accepts_diff_264_0_rxode2parse }; -unsigned char d_scanner_243_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_264_0_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_243_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_264_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_243_1_rxode2parse[] = {&d_shift_193_rxode2parse,NULL}; +D_Shift * d_shift_264_1_rxode2parse[] = {&d_shift_212_rxode2parse,NULL}; -D_Shift * d_accepts_diff_247_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_247_rxode2parse[] = { -d_accepts_diff_247_0_rxode2parse +D_Shift * d_accepts_diff_327_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_327_rxode2parse[] = { +d_accepts_diff_327_0_rxode2parse }; -unsigned char d_scanner_247_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_327_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, }; -unsigned char d_scanner_247_1_0_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_327_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_accepts_diff_305_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_305_rxode2parse[] = { -d_accepts_diff_305_0_rxode2parse -}; - -unsigned char d_scanner_305_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_327_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_305_1_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_327_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, +0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -unsigned char d_scanner_305_2_1_rxode2parse[SCANNER_BLOCK_SIZE] = { -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +D_Shift * d_shift_327_4_rxode2parse[] = {&d_shift_10_rxode2parse,NULL}; + +D_Shift * d_accepts_diff_332_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_332_rxode2parse[] = { +d_accepts_diff_332_0_rxode2parse }; -unsigned char d_scanner_305_3_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_332_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_305_4_rxode2parse[] = {&d_shift_10_rxode2parse,NULL}; +D_Shift * d_shift_332_1_rxode2parse[] = {&d_shift_191_rxode2parse,NULL}; -D_Shift * d_accepts_diff_310_0_rxode2parse[] = {0}; -D_Shift ** d_accepts_diff_310_rxode2parse[] = { -d_accepts_diff_310_0_rxode2parse +D_Shift * d_accepts_diff_364_0_rxode2parse[] = {0}; +D_Shift ** d_accepts_diff_364_rxode2parse[] = { +d_accepts_diff_364_0_rxode2parse }; -unsigned char d_scanner_310_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { +unsigned char d_scanner_364_0_1_rxode2parse[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -D_Shift * d_shift_310_1_rxode2parse[] = {&d_shift_172_rxode2parse,NULL}; +D_Shift * d_shift_364_1_rxode2parse[] = {&d_shift_108_rxode2parse,NULL}; -SB_uint8 d_scanner_0_rxode2parse[102] = { +SB_uint8 d_scanner_0_rxode2parse[107] = { {NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_0_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_0_1_1_rxode2parse @@ -3554,25 +3745,25 @@ SB_uint8 d_scanner_0_rxode2parse[102] = { , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_42_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_0_43_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_43_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_44_1_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_0_44_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_45_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_46_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_46_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_0_47_1_rxode2parse +{d_shift_0_47_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_0_48_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_49_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_50_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_51_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_52_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_53_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, @@ -3594,23 +3785,23 @@ SB_uint8 d_scanner_0_rxode2parse[102] = { , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_62_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_63_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_63_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_64_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_64_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_65_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_66_1_rxode2parse +{d_shift_0_66_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_67_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_68_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_68_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_69_1_rxode2parse +{d_shift_0_69_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_70_1_rxode2parse +{d_shift_0_70_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_71_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_71_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_72_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, @@ -3628,53 +3819,63 @@ SB_uint8 d_scanner_0_rxode2parse[102] = { , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_79_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_80_1_rxode2parse +{d_shift_0_80_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_81_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_81_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_82_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_83_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_84_1_rxode2parse +{d_shift_0_84_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_85_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_85_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_86_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_86_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_86_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_87_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_87_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_87_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_88_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_89_1_rxode2parse +{d_shift_0_89_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_30_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_90_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_90_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_91_1_rxode2parse +{d_shift_0_91_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_91_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_92_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_92_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_93_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_93_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_94_1_rxode2parse +{d_shift_0_30_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_86_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_95_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_96_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_97_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_97_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_98_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_99_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_99_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_100_1_rxode2parse +{d_shift_0_90_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_101_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_0_102_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_0_102_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_0_104_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_105_1_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_0_106_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_0_rxode2parse[102] = { +SB_trans_uint8 d_transition_0_rxode2parse[107] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -3767,17 +3968,21 @@ SB_trans_uint8 d_transition_0_rxode2parse[102] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_46_0_rxode2parse, d_accepts_diff_0_46_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_47_0_rxode2parse, d_accepts_diff_0_47_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_51_0_rxode2parse, d_accepts_diff_0_51_1_rxode2parse +{{d_accepts_diff_0_52_0_rxode2parse, d_accepts_diff_0_52_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -3805,31 +4010,33 @@ SB_trans_uint8 d_transition_0_rxode2parse[102] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_65_0_rxode2parse, d_accepts_diff_0_65_1_rxode2parse +{{d_accepts_diff_0_67_0_rxode2parse, d_accepts_diff_0_67_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_68_0_rxode2parse, d_accepts_diff_0_68_1_rxode2parse +{{d_accepts_diff_0_70_0_rxode2parse, d_accepts_diff_0_70_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_71_0_rxode2parse, d_accepts_diff_0_71_1_rxode2parse +{{d_accepts_diff_0_74_0_rxode2parse, d_accepts_diff_0_74_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_74_0_rxode2parse, d_accepts_diff_0_74_1_rxode2parse +{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -3837,7 +4044,9 @@ SB_trans_uint8 d_transition_0_rxode2parse[102] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_81_0_rxode2parse, d_accepts_diff_0_81_1_rxode2parse +{{d_accepts_diff_0_84_0_rxode2parse, d_accepts_diff_0_84_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -3845,11 +4054,11 @@ SB_trans_uint8 d_transition_0_rxode2parse[102] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_85_0_rxode2parse, d_accepts_diff_0_85_1_rxode2parse +{{d_accepts_diff_0_89_0_rxode2parse, d_accepts_diff_0_89_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_86_0_rxode2parse, d_accepts_diff_0_86_1_rxode2parse +{{d_accepts_diff_0_90_0_rxode2parse, d_accepts_diff_0_90_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_87_0_rxode2parse, d_accepts_diff_0_87_1_rxode2parse +{{d_accepts_diff_0_91_0_rxode2parse, d_accepts_diff_0_91_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -3859,25 +4068,27 @@ SB_trans_uint8 d_transition_0_rxode2parse[102] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_97_0_rxode2parse, d_accepts_diff_0_97_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_93_0_rxode2parse, d_accepts_diff_0_93_1_rxode2parse +{{d_accepts_diff_0_98_0_rxode2parse, d_accepts_diff_0_98_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_86_0_rxode2parse, d_accepts_diff_0_95_1_rxode2parse +{{d_accepts_diff_0_90_0_rxode2parse, d_accepts_diff_0_100_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse +{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_97_0_rxode2parse, d_accepts_diff_0_97_1_rxode2parse +{{d_accepts_diff_0_102_0_rxode2parse, d_accepts_diff_0_102_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_97_0_rxode2parse, d_accepts_diff_0_97_1_rxode2parse +{{d_accepts_diff_0_102_0_rxode2parse, d_accepts_diff_0_102_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse +{{d_accepts_diff_0_106_0_rxode2parse, d_accepts_diff_0_106_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; @@ -3895,54 +4106,54 @@ SB_trans_uint8 d_transition_3_rxode2parse[2] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_25_rxode2parse[2] = { -{NULL, {d_scanner_25_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_26_rxode2parse[2] = { +{NULL, {d_scanner_26_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_25_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_26_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_25_rxode2parse[2] = { +SB_trans_uint8 d_transition_26_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_58_rxode2parse[2] = { -{NULL, {d_scanner_58_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_59_rxode2parse[2] = { +{NULL, {d_scanner_59_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_58_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_59_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_58_rxode2parse[2] = { +SB_trans_uint8 d_transition_59_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_63_rxode2parse[8] = { -{NULL, {d_scanner_63_0_0_rxode2parse, d_scanner_63_0_1_rxode2parse +SB_uint8 d_scanner_67_rxode2parse[8] = { +{NULL, {d_scanner_67_0_0_rxode2parse, d_scanner_67_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_63_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_67_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_63_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_67_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_25_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_26_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_63_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_67_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_63_5_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_67_5_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_63_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_67_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_63_7_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_67_7_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_63_rxode2parse[8] = { +SB_trans_uint8 d_transition_67_rxode2parse[8] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -3961,16 +4172,42 @@ SB_trans_uint8 d_transition_63_rxode2parse[8] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_68_rxode2parse[3] = { -{NULL, {d_scanner_68_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_68_rxode2parse[5] = { +{NULL, {d_scanner_68_0_0_rxode2parse, d_scanner_68_0_1_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{NULL, {d_scanner_68_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_26_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_67_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_67_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} +}; + +SB_trans_uint8 d_transition_68_rxode2parse[5] = { +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} +}; + +SB_uint8 d_scanner_75_rxode2parse[3] = { +{NULL, {d_scanner_75_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_68_1_rxode2parse, {d_scanner_68_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_75_1_rxode2parse, {d_scanner_75_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_68_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_75_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_68_rxode2parse[3] = { +SB_trans_uint8 d_transition_75_rxode2parse[3] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -3979,82 +4216,92 @@ SB_trans_uint8 d_transition_68_rxode2parse[3] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_70_rxode2parse[2] = { -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_25_0_0_rxode2parse +SB_uint8 d_scanner_77_rxode2parse[2] = { +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_26_0_0_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_70_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_77_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_70_rxode2parse[2] = { +SB_trans_uint8 d_transition_77_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_71_rxode2parse[29] = { -{NULL, {d_scanner_71_0_0_rxode2parse, d_scanner_71_0_1_rxode2parse +SB_uint8 d_scanner_78_rxode2parse[34] = { +{NULL, {d_scanner_78_0_0_rxode2parse, d_scanner_78_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_71_2_0_rxode2parse, d_scanner_71_2_1_rxode2parse - , d_scanner_71_2_2_rxode2parse, d_scanner_71_2_2_rxode2parse}}, +{NULL, {d_scanner_78_2_0_rxode2parse, d_scanner_78_2_1_rxode2parse + , d_scanner_78_2_2_rxode2parse, d_scanner_78_2_2_rxode2parse}}, +{NULL, {d_scanner_78_3_0_rxode2parse, d_scanner_78_3_1_rxode2parse + , d_scanner_78_3_2_rxode2parse, d_scanner_78_3_2_rxode2parse}}, {d_shift_3_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_78_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_78_7_0_rxode2parse, d_scanner_78_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_71_6_0_rxode2parse, d_scanner_71_6_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_7_1_rxode2parse +{d_shift_0_3_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_3_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_7_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_10_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_9_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_11_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_10_1_rxode2parse +{d_shift_0_10_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_10_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_7_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_13_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_12_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_14_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_13_1_rxode2parse +{NULL, {d_scanner_78_2_0_rxode2parse, d_scanner_78_2_1_rxode2parse + , d_scanner_78_2_2_rxode2parse, d_scanner_78_2_2_rxode2parse}}, +{d_shift_78_16_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_71_2_0_rxode2parse, d_scanner_71_2_1_rxode2parse - , d_scanner_71_2_2_rxode2parse, d_scanner_71_2_2_rxode2parse}}, -{d_shift_71_15_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_78_17_0_rxode2parse, d_scanner_78_17_1_rxode2parse + , d_scanner_78_17_1_rxode2parse, d_scanner_78_17_1_rxode2parse}}, +{NULL, {d_scanner_78_3_0_rxode2parse, d_scanner_78_3_1_rxode2parse + , d_scanner_78_3_2_rxode2parse, d_scanner_78_3_2_rxode2parse}}, +{d_shift_78_19_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_71_16_0_rxode2parse, d_scanner_71_16_1_rxode2parse - , d_scanner_71_16_1_rxode2parse, d_scanner_71_16_1_rxode2parse}}, -{d_shift_0_20_rxode2parse, {d_scanner_71_17_0_rxode2parse, d_scanner_71_6_1_rxode2parse +{NULL, {d_scanner_78_20_0_rxode2parse, d_scanner_78_20_1_rxode2parse + , d_scanner_78_20_1_rxode2parse, d_scanner_78_20_1_rxode2parse}}, +{d_shift_0_20_rxode2parse, {d_scanner_78_21_0_rxode2parse, d_scanner_78_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_18_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_22_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_19_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_23_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_20_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_24_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_21_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_25_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_71_2_0_rxode2parse, d_scanner_71_2_1_rxode2parse - , d_scanner_71_2_2_rxode2parse, d_scanner_71_2_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_23_1_rxode2parse +{NULL, {d_scanner_78_2_0_rxode2parse, d_scanner_78_2_1_rxode2parse + , d_scanner_78_2_2_rxode2parse, d_scanner_78_2_2_rxode2parse}}, +{NULL, {d_scanner_78_3_0_rxode2parse, d_scanner_78_3_1_rxode2parse + , d_scanner_78_3_2_rxode2parse, d_scanner_78_3_2_rxode2parse}}, +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_28_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_7_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_7_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_26_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_31_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_7_1_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_77_rxode2parse, {d_scanner_71_7_0_rxode2parse, d_scanner_71_7_1_rxode2parse +{d_shift_0_80_rxode2parse, {d_scanner_78_8_0_rxode2parse, d_scanner_78_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_71_rxode2parse[29] = { +SB_trans_uint8 d_transition_78_rxode2parse[34] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4071,13 +4318,17 @@ SB_trans_uint8 d_transition_71_rxode2parse[29] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4103,89 +4354,95 @@ SB_trans_uint8 d_transition_71_rxode2parse[29] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_73_rxode2parse[2] = { -{NULL, {d_scanner_73_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_80_rxode2parse[2] = { +{NULL, {d_scanner_80_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_73_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_80_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_73_rxode2parse[2] = { +SB_trans_uint8 d_transition_80_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_74_rxode2parse[20] = { -{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_74_0_1_rxode2parse +SB_uint8 d_scanner_81_rxode2parse[20] = { +{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_81_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_74_1_1_rxode2parse +{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_81_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_3_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_4_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_4_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_5_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_10_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_7_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_8_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_20_rxode2parse, {d_scanner_74_9_0_rxode2parse, d_scanner_74_1_1_rxode2parse +{d_shift_0_20_rxode2parse, {d_scanner_81_9_0_rxode2parse, d_scanner_81_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_10_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_10_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_11_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_11_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_12_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_12_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_13_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_13_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_14_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_14_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_74_17_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_81_17_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_77_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_80_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_74_rxode2parse[20] = { +SB_trans_uint8 d_transition_81_rxode2parse[20] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4203,94 +4460,94 @@ SB_trans_uint8 d_transition_74_rxode2parse[20] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_75_rxode2parse[36] = { -{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_75_0_1_rxode2parse +SB_uint8 d_scanner_82_rxode2parse[36] = { +{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_82_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_75_1_1_rxode2parse +{NULL, {d_scanner_0_0_0_rxode2parse, d_scanner_82_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_3_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_3_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_5_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_6_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_7_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_8_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_0_10_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_10_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_10_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_11_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_11_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_12_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_12_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_20_rxode2parse, {d_scanner_75_13_0_rxode2parse, d_scanner_75_1_1_rxode2parse +{d_shift_0_20_rxode2parse, {d_scanner_82_13_0_rxode2parse, d_scanner_82_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_14_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_14_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_15_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_15_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_16_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_16_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_17_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_17_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_18_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_18_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_19_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_19_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_20_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_20_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_21_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_21_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_22_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_82_22_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_23_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_23_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_24_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_24_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_26_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_82_26_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_28_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_28_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_29_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_29_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_30_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_30_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_77_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_0_80_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_75_33_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_82_33_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_34_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_82_34_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_35_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse +{d_shift_82_35_rxode2parse, {d_scanner_0_2_0_rxode2parse, d_scanner_0_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_75_rxode2parse[36] = { +SB_trans_uint8 d_transition_82_rxode2parse[36] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4299,7 +4556,7 @@ SB_trans_uint8 d_transition_75_rxode2parse[36] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_87_0_rxode2parse, d_accepts_diff_0_87_1_rxode2parse +{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4309,7 +4566,7 @@ SB_trans_uint8 d_transition_75_rxode2parse[36] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4341,11 +4598,11 @@ SB_trans_uint8 d_transition_75_rxode2parse[36] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_70_0_rxode2parse, d_accepts_diff_0_70_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4353,48 +4610,68 @@ SB_trans_uint8 d_transition_75_rxode2parse[36] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_68_0_rxode2parse, d_accepts_diff_0_68_1_rxode2parse +{{d_accepts_diff_0_84_0_rxode2parse, d_accepts_diff_0_84_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_81_0_rxode2parse, d_accepts_diff_0_81_1_rxode2parse +{{d_accepts_diff_0_91_0_rxode2parse, d_accepts_diff_0_91_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_76_rxode2parse[2] = { -{NULL, {d_scanner_76_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_83_rxode2parse[2] = { +{NULL, {d_scanner_83_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_76_rxode2parse[2] = { +SB_trans_uint8 d_transition_83_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_92_rxode2parse[6] = { -{NULL, {d_scanner_92_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_100_rxode2parse[11] = { +{NULL, {d_scanner_100_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_92_1_0_rxode2parse, d_scanner_92_1_1_rxode2parse - , d_scanner_92_1_2_rxode2parse, d_scanner_92_1_2_rxode2parse}}, -{NULL, {d_scanner_92_1_0_rxode2parse, d_scanner_92_1_1_rxode2parse - , d_scanner_92_1_2_rxode2parse, d_scanner_92_1_2_rxode2parse}}, -{d_shift_71_15_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_100_1_0_rxode2parse, d_scanner_100_1_1_rxode2parse + , d_scanner_100_1_2_rxode2parse, d_scanner_100_1_2_rxode2parse}}, +{NULL, {d_scanner_100_2_0_rxode2parse, d_scanner_100_2_1_rxode2parse + , d_scanner_100_2_2_rxode2parse, d_scanner_100_2_2_rxode2parse}}, +{NULL, {d_scanner_100_1_0_rxode2parse, d_scanner_100_1_1_rxode2parse + , d_scanner_100_1_2_rxode2parse, d_scanner_100_1_2_rxode2parse}}, +{d_shift_78_16_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_92_4_0_rxode2parse, d_scanner_92_4_1_rxode2parse - , d_scanner_92_4_1_rxode2parse, d_scanner_92_4_1_rxode2parse}}, -{NULL, {d_scanner_92_1_0_rxode2parse, d_scanner_92_1_1_rxode2parse - , d_scanner_92_1_2_rxode2parse, d_scanner_92_1_2_rxode2parse}} +{NULL, {d_scanner_100_5_0_rxode2parse, d_scanner_100_5_1_rxode2parse + , d_scanner_100_5_1_rxode2parse, d_scanner_100_5_1_rxode2parse}}, +{NULL, {d_scanner_100_2_0_rxode2parse, d_scanner_100_2_1_rxode2parse + , d_scanner_100_2_2_rxode2parse, d_scanner_100_2_2_rxode2parse}}, +{d_shift_78_19_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{NULL, {d_scanner_100_8_0_rxode2parse, d_scanner_100_8_1_rxode2parse + , d_scanner_100_8_1_rxode2parse, d_scanner_100_8_1_rxode2parse}}, +{NULL, {d_scanner_100_1_0_rxode2parse, d_scanner_100_1_1_rxode2parse + , d_scanner_100_1_2_rxode2parse, d_scanner_100_1_2_rxode2parse}}, +{NULL, {d_scanner_100_2_0_rxode2parse, d_scanner_100_2_1_rxode2parse + , d_scanner_100_2_2_rxode2parse, d_scanner_100_2_2_rxode2parse}} }; -SB_trans_uint8 d_transition_92_rxode2parse[6] = { +SB_trans_uint8 d_transition_100_rxode2parse[11] = { +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4409,18 +4686,18 @@ SB_trans_uint8 d_transition_92_rxode2parse[6] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_111_rxode2parse[4] = { -{NULL, {d_scanner_111_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_122_rxode2parse[4] = { +{NULL, {d_scanner_68_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_111_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_122_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_25_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_26_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_63_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_67_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_111_rxode2parse[4] = { +SB_trans_uint8 d_transition_122_rxode2parse[4] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4431,80 +4708,90 @@ SB_trans_uint8 d_transition_111_rxode2parse[4] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_118_rxode2parse[2] = { -{d_shift_118_0_rxode2parse, {d_scanner_118_0_0_rxode2parse, d_scanner_118_0_1_rxode2parse - , d_scanner_118_0_1_rxode2parse, d_scanner_118_0_1_rxode2parse}}, -{d_shift_118_0_rxode2parse, {d_scanner_118_0_0_rxode2parse, d_scanner_118_0_1_rxode2parse - , d_scanner_118_0_1_rxode2parse, d_scanner_118_0_1_rxode2parse}} +SB_uint8 d_scanner_133_rxode2parse[2] = { +{d_shift_133_0_rxode2parse, {d_scanner_133_0_0_rxode2parse, d_scanner_133_0_1_rxode2parse + , d_scanner_133_0_1_rxode2parse, d_scanner_133_0_1_rxode2parse}}, +{d_shift_133_0_rxode2parse, {d_scanner_133_0_0_rxode2parse, d_scanner_133_0_1_rxode2parse + , d_scanner_133_0_1_rxode2parse, d_scanner_133_0_1_rxode2parse}} }; -SB_trans_uint8 d_transition_118_rxode2parse[2] = { +SB_trans_uint8 d_transition_133_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_122_rxode2parse[28] = { -{NULL, {d_scanner_122_0_0_rxode2parse, d_scanner_122_0_1_rxode2parse +SB_uint8 d_scanner_137_rxode2parse[33] = { +{NULL, {d_scanner_137_0_0_rxode2parse, d_scanner_137_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_122_2_0_rxode2parse, d_scanner_122_2_1_rxode2parse - , d_scanner_122_2_2_rxode2parse, d_scanner_122_2_2_rxode2parse}}, -{d_shift_71_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_137_2_0_rxode2parse, d_scanner_137_2_1_rxode2parse + , d_scanner_137_2_2_rxode2parse, d_scanner_137_2_2_rxode2parse}}, +{NULL, {d_scanner_137_3_0_rxode2parse, d_scanner_137_3_1_rxode2parse + , d_scanner_137_3_2_rxode2parse, d_scanner_137_3_2_rxode2parse}}, +{d_shift_78_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_122_5_0_rxode2parse, d_scanner_122_5_1_rxode2parse +{NULL, {d_scanner_137_6_0_rxode2parse, d_scanner_0_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_6_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_3_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_6_1_rxode2parse +{d_shift_0_3_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_8_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_9_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_9_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_10_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_10_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_6_1_rxode2parse +{d_shift_0_10_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_11_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_12_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_12_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_13_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_122_2_0_rxode2parse, d_scanner_122_2_1_rxode2parse - , d_scanner_122_2_2_rxode2parse, d_scanner_122_2_2_rxode2parse}}, -{d_shift_71_15_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_137_2_0_rxode2parse, d_scanner_137_2_1_rxode2parse + , d_scanner_137_2_2_rxode2parse, d_scanner_137_2_2_rxode2parse}}, +{d_shift_78_16_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_122_15_0_rxode2parse, d_scanner_122_15_1_rxode2parse - , d_scanner_122_15_1_rxode2parse, d_scanner_122_15_1_rxode2parse}}, -{d_shift_0_20_rxode2parse, {d_scanner_122_16_0_rxode2parse, d_scanner_122_5_1_rxode2parse +{NULL, {d_scanner_137_16_0_rxode2parse, d_scanner_137_16_1_rxode2parse + , d_scanner_137_16_1_rxode2parse, d_scanner_137_16_1_rxode2parse}}, +{NULL, {d_scanner_137_3_0_rxode2parse, d_scanner_137_3_1_rxode2parse + , d_scanner_137_3_2_rxode2parse, d_scanner_137_3_2_rxode2parse}}, +{d_shift_78_19_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{NULL, {d_scanner_78_17_0_rxode2parse, d_scanner_78_17_1_rxode2parse + , d_scanner_78_17_1_rxode2parse, d_scanner_78_17_1_rxode2parse}}, +{d_shift_0_20_rxode2parse, {d_scanner_0_20_0_rxode2parse, d_scanner_0_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_17_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_21_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_18_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_22_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_19_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_23_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_20_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_24_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_122_2_0_rxode2parse, d_scanner_122_2_1_rxode2parse - , d_scanner_122_2_2_rxode2parse, d_scanner_122_2_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_22_1_rxode2parse +{NULL, {d_scanner_137_2_0_rxode2parse, d_scanner_137_2_1_rxode2parse + , d_scanner_137_2_2_rxode2parse, d_scanner_137_2_2_rxode2parse}}, +{NULL, {d_scanner_137_3_0_rxode2parse, d_scanner_137_3_1_rxode2parse + , d_scanner_137_3_2_rxode2parse, d_scanner_137_3_2_rxode2parse}}, +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_27_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_6_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_6_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_25_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_30_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_6_1_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_77_rxode2parse, {d_scanner_122_6_0_rxode2parse, d_scanner_122_6_1_rxode2parse +{d_shift_0_80_rxode2parse, {d_scanner_137_7_0_rxode2parse, d_scanner_137_7_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_122_rxode2parse[28] = { +SB_trans_uint8 d_transition_137_rxode2parse[33] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4519,13 +4806,15 @@ SB_trans_uint8 d_transition_122_rxode2parse[28] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4551,64 +4840,72 @@ SB_trans_uint8 d_transition_122_rxode2parse[28] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_131_rxode2parse[21] = { -{NULL, {d_scanner_131_0_0_rxode2parse, d_scanner_131_0_1_rxode2parse +SB_uint8 d_scanner_146_rxode2parse[21] = { +{NULL, {d_scanner_146_0_0_rxode2parse, d_scanner_146_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_3_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_131_2_0_rxode2parse, d_scanner_131_2_1_rxode2parse +{NULL, {d_scanner_146_2_0_rxode2parse, d_scanner_146_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_3_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_3_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_3_1_rxode2parse +{d_shift_0_3_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_5_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_6_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_10_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_3_1_rxode2parse +{d_shift_0_10_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_8_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_9_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_9_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_20_rxode2parse, {d_scanner_131_10_0_rxode2parse, d_scanner_131_2_1_rxode2parse +{d_shift_0_20_rxode2parse, {d_scanner_146_10_0_rxode2parse, d_scanner_146_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_11_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_11_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_12_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_12_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_13_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_13_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_14_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_14_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_15_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_15_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_3_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_3_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_18_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_18_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_3_1_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_77_rxode2parse, {d_scanner_131_3_0_rxode2parse, d_scanner_131_3_1_rxode2parse +{d_shift_0_80_rxode2parse, {d_scanner_146_3_0_rxode2parse, d_scanner_146_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_131_rxode2parse[21] = { +SB_trans_uint8 d_transition_146_rxode2parse[21] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4617,13 +4914,13 @@ SB_trans_uint8 d_transition_131_rxode2parse[21] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse +{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4641,181 +4938,181 @@ SB_trans_uint8 d_transition_131_rxode2parse[21] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_133_rxode2parse[2] = { -{NULL, {d_scanner_133_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_151_rxode2parse[2] = { +{NULL, {d_scanner_151_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_133_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_151_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_133_rxode2parse[2] = { +SB_trans_uint8 d_transition_151_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_144_rxode2parse[60] = { -{NULL, {d_scanner_144_0_0_rxode2parse, d_scanner_144_0_1_rxode2parse +SB_uint8 d_scanner_162_rxode2parse[60] = { +{NULL, {d_scanner_162_0_0_rxode2parse, d_scanner_162_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, {d_shift_3_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_144_2_0_rxode2parse, d_scanner_144_2_1_rxode2parse +{NULL, {d_scanner_162_2_0_rxode2parse, d_scanner_162_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_3_rxode2parse, {d_scanner_144_3_0_rxode2parse, d_scanner_144_3_1_rxode2parse +{d_shift_162_3_rxode2parse, {d_scanner_162_3_0_rxode2parse, d_scanner_162_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_3_rxode2parse, {d_scanner_144_4_0_rxode2parse, d_scanner_144_3_1_rxode2parse +{d_shift_162_3_rxode2parse, {d_scanner_162_4_0_rxode2parse, d_scanner_162_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_6_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_3_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_3_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_8_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_9_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_9_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_10_0_rxode2parse, d_scanner_144_10_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_10_0_rxode2parse, d_scanner_162_10_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_11_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_11_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_10_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_10_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_13_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_13_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_14_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_14_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_15_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_15_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_16_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_16_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_144_17_0_rxode2parse, d_scanner_144_2_1_rxode2parse +{NULL, {d_scanner_162_17_0_rxode2parse, d_scanner_162_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_144_18_0_rxode2parse, d_scanner_144_18_1_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_162_18_0_rxode2parse, d_scanner_162_18_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_20_rxode2parse, {d_scanner_144_19_0_rxode2parse, d_scanner_144_2_1_rxode2parse +{d_shift_0_20_rxode2parse, {d_scanner_162_19_0_rxode2parse, d_scanner_162_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_144_20_0_rxode2parse, d_scanner_144_18_1_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_162_20_0_rxode2parse, d_scanner_162_18_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_144_3_0_rxode2parse, d_scanner_144_3_1_rxode2parse +{NULL, {d_scanner_162_3_0_rxode2parse, d_scanner_162_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_144_22_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_162_22_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_23_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_23_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_24_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_24_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_25_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_25_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_144_26_1_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_162_26_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_27_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_27_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_28_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_28_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_29_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_29_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_30_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_30_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_31_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_31_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_32_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_32_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_33_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_33_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_144_34_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_162_34_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_144_20_0_rxode2parse, d_scanner_144_18_1_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_162_20_0_rxode2parse, d_scanner_162_18_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_144_36_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_162_36_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_37_rxode2parse, {d_scanner_144_36_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_162_37_rxode2parse, {d_scanner_162_36_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_22_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_82_22_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_39_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_39_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_40_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_40_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_144_41_1_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_162_41_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_26_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_82_26_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_44_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_44_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_46_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_46_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_47_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_47_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_144_48_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_162_48_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_144_48_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_162_48_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_50_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_50_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_67_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_0_69_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_53_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_53_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_77_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_80_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_55_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_55_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_34_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_82_34_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_57_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_57_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_75_35_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_82_35_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_92_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_96_rxode2parse, {d_scanner_162_5_0_rxode2parse, d_scanner_162_5_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_144_rxode2parse[60] = { +SB_trans_uint8 d_transition_162_rxode2parse[60] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_85_0_rxode2parse, d_accepts_diff_144_3_1_rxode2parse +{{d_accepts_diff_0_47_0_rxode2parse, d_accepts_diff_162_3_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_144_4_0_rxode2parse, d_accepts_diff_144_3_1_rxode2parse +{{d_accepts_diff_162_4_0_rxode2parse, d_accepts_diff_162_3_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_144_10_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse +{{d_accepts_diff_162_10_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4845,7 +5142,7 @@ SB_trans_uint8 d_transition_144_rxode2parse[60] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_81_0_rxode2parse, d_accepts_diff_0_81_1_rxode2parse +{{d_accepts_diff_0_84_0_rxode2parse, d_accepts_diff_0_84_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4867,7 +5164,7 @@ SB_trans_uint8 d_transition_144_rxode2parse[60] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_68_0_rxode2parse, d_accepts_diff_0_68_1_rxode2parse +{{d_accepts_diff_0_97_0_rxode2parse, d_accepts_diff_0_97_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4875,9 +5172,9 @@ SB_trans_uint8 d_transition_144_rxode2parse[60] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_97_0_rxode2parse, d_accepts_diff_0_97_1_rxode2parse +{{d_accepts_diff_0_70_0_rxode2parse, d_accepts_diff_0_70_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4893,13 +5190,13 @@ SB_trans_uint8 d_transition_144_rxode2parse[60] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_86_0_rxode2parse, d_accepts_diff_0_95_1_rxode2parse +{{d_accepts_diff_0_90_0_rxode2parse, d_accepts_diff_0_100_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -4907,26 +5204,26 @@ SB_trans_uint8 d_transition_144_rxode2parse[60] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_87_0_rxode2parse, d_accepts_diff_0_87_1_rxode2parse +{{d_accepts_diff_0_91_0_rxode2parse, d_accepts_diff_0_91_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_46_0_rxode2parse, d_accepts_diff_0_46_1_rxode2parse +{{d_accepts_diff_0_102_0_rxode2parse, d_accepts_diff_0_102_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_146_rxode2parse[5] = { -{NULL, {d_scanner_146_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_164_rxode2parse[5] = { +{NULL, {d_scanner_164_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_146_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_164_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_146_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_164_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_146_3_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_164_3_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_146_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_164_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_146_rxode2parse[5] = { +SB_trans_uint8 d_transition_164_rxode2parse[5] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4939,30 +5236,30 @@ SB_trans_uint8 d_transition_146_rxode2parse[5] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_163_rxode2parse[2] = { -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_163_0_1_rxode2parse +SB_uint8 d_scanner_182_rxode2parse[2] = { +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_182_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_163_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_182_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_163_rxode2parse[2] = { +SB_trans_uint8 d_transition_182_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_170_rxode2parse[3] = { -{NULL, {d_scanner_170_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_189_rxode2parse[3] = { +{NULL, {d_scanner_189_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_3_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_162_3_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_3_rxode2parse, {d_scanner_170_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_162_3_rxode2parse, {d_scanner_189_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_170_rxode2parse[3] = { +SB_trans_uint8 d_transition_189_rxode2parse[3] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -4971,22 +5268,22 @@ SB_trans_uint8 d_transition_170_rxode2parse[3] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_172_rxode2parse[6] = { -{NULL, {d_scanner_73_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_191_rxode2parse[6] = { +{NULL, {d_scanner_80_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_172_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_191_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_172_2_1_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_191_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_172_3_1_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_191_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_172_4_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_191_4_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_172_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_191_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_172_rxode2parse[6] = { +SB_trans_uint8 d_transition_191_rxode2parse[6] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5001,45 +5298,45 @@ SB_trans_uint8 d_transition_172_rxode2parse[6] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_192_rxode2parse[14] = { -{NULL, {d_scanner_192_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_212_rxode2parse[14] = { +{NULL, {d_scanner_212_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_192_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_212_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_3_rxode2parse, {d_scanner_192_2_0_rxode2parse, d_scanner_192_2_1_rxode2parse +{d_shift_162_3_rxode2parse, {d_scanner_212_2_0_rxode2parse, d_scanner_212_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_3_rxode2parse, {d_scanner_192_3_0_rxode2parse, d_scanner_192_2_1_rxode2parse +{d_shift_162_3_rxode2parse, {d_scanner_212_3_0_rxode2parse, d_scanner_212_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_192_1_0_rxode2parse, d_scanner_192_4_1_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_212_1_0_rxode2parse, d_scanner_212_4_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_192_5_0_rxode2parse, d_scanner_192_4_1_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_212_5_0_rxode2parse, d_scanner_212_4_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_192_2_0_rxode2parse, d_scanner_192_2_1_rxode2parse +{NULL, {d_scanner_212_2_0_rxode2parse, d_scanner_212_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_192_7_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_212_7_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_192_8_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_212_8_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_192_5_0_rxode2parse, d_scanner_192_4_1_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_212_5_0_rxode2parse, d_scanner_212_4_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_192_10_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_212_10_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_37_rxode2parse, {d_scanner_192_10_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_162_37_rxode2parse, {d_scanner_212_10_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_192_12_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_212_12_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_144_18_rxode2parse, {d_scanner_192_12_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_162_18_rxode2parse, {d_scanner_212_12_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_192_rxode2parse[14] = { +SB_trans_uint8 d_transition_212_rxode2parse[14] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_192_2_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_212_2_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_192_3_0_rxode2parse, d_accepts_diff_192_2_1_rxode2parse +{{d_accepts_diff_212_3_0_rxode2parse, d_accepts_diff_212_2_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -5063,64 +5360,74 @@ SB_trans_uint8 d_transition_192_rxode2parse[14] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_198_rxode2parse[27] = { -{NULL, {d_scanner_198_0_0_rxode2parse, d_scanner_198_0_1_rxode2parse +SB_uint8 d_scanner_219_rxode2parse[32] = { +{NULL, {d_scanner_219_0_0_rxode2parse, d_scanner_219_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_198_1_0_rxode2parse, d_scanner_198_1_1_rxode2parse - , d_scanner_198_1_2_rxode2parse, d_scanner_198_1_2_rxode2parse}}, -{d_shift_71_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_219_1_0_rxode2parse, d_scanner_219_1_1_rxode2parse + , d_scanner_219_1_2_rxode2parse, d_scanner_219_1_2_rxode2parse}}, +{NULL, {d_scanner_219_2_0_rxode2parse, d_scanner_219_2_1_rxode2parse + , d_scanner_219_2_2_rxode2parse, d_scanner_219_2_2_rxode2parse}}, +{d_shift_78_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_198_4_0_rxode2parse, d_scanner_198_4_1_rxode2parse +{NULL, {d_scanner_219_5_0_rxode2parse, d_scanner_162_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_3_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_3_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_7_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_8_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_8_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_9_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_10_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_10_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_10_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_11_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_11_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_12_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_198_1_0_rxode2parse, d_scanner_198_1_1_rxode2parse - , d_scanner_198_1_2_rxode2parse, d_scanner_198_1_2_rxode2parse}}, -{d_shift_71_15_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_219_1_0_rxode2parse, d_scanner_219_1_1_rxode2parse + , d_scanner_219_1_2_rxode2parse, d_scanner_219_1_2_rxode2parse}}, +{d_shift_78_16_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_198_14_0_rxode2parse, d_scanner_198_14_1_rxode2parse - , d_scanner_198_14_1_rxode2parse, d_scanner_198_14_1_rxode2parse}}, -{d_shift_0_20_rxode2parse, {d_scanner_198_15_0_rxode2parse, d_scanner_198_4_1_rxode2parse +{NULL, {d_scanner_219_15_0_rxode2parse, d_scanner_219_15_1_rxode2parse + , d_scanner_219_15_1_rxode2parse, d_scanner_219_15_1_rxode2parse}}, +{NULL, {d_scanner_219_2_0_rxode2parse, d_scanner_219_2_1_rxode2parse + , d_scanner_219_2_2_rxode2parse, d_scanner_219_2_2_rxode2parse}}, +{d_shift_78_19_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_16_1_rxode2parse +{NULL, {d_scanner_137_16_0_rxode2parse, d_scanner_137_16_1_rxode2parse + , d_scanner_137_16_1_rxode2parse, d_scanner_137_16_1_rxode2parse}}, +{d_shift_0_20_rxode2parse, {d_scanner_162_19_0_rxode2parse, d_scanner_162_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_17_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_20_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_18_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_21_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_19_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_22_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_198_1_0_rxode2parse, d_scanner_198_1_1_rxode2parse - , d_scanner_198_1_2_rxode2parse, d_scanner_198_1_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_21_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_23_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_48_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{NULL, {d_scanner_219_1_0_rxode2parse, d_scanner_219_1_1_rxode2parse + , d_scanner_219_1_2_rxode2parse, d_scanner_219_1_2_rxode2parse}}, +{NULL, {d_scanner_219_2_0_rxode2parse, d_scanner_219_2_1_rxode2parse + , d_scanner_219_2_2_rxode2parse, d_scanner_219_2_2_rxode2parse}}, +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_26_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_51_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_49_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_2_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_198_24_1_rxode2parse +{d_shift_0_52_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_65_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_2_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_29_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_0_77_rxode2parse, {d_scanner_144_5_0_rxode2parse, d_scanner_144_5_1_rxode2parse +{d_shift_0_67_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_6_1_rxode2parse + , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, +{d_shift_0_80_rxode2parse, {d_scanner_219_6_0_rxode2parse, d_scanner_219_6_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_198_rxode2parse[27] = { +SB_trans_uint8 d_transition_219_rxode2parse[32] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5133,13 +5440,15 @@ SB_trans_uint8 d_transition_198_rxode2parse[27] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_77_0_rxode2parse, d_accepts_diff_0_77_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_99_0_rxode2parse, d_accepts_diff_0_99_1_rxode2parse +{{d_accepts_diff_0_80_0_rxode2parse, d_accepts_diff_0_80_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -5165,81 +5474,89 @@ SB_trans_uint8 d_transition_198_rxode2parse[27] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_96_0_rxode2parse, d_accepts_diff_0_96_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse + , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +{{d_accepts_diff_0_101_0_rxode2parse, d_accepts_diff_0_101_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_92_0_rxode2parse, d_accepts_diff_0_92_1_rxode2parse +{{d_accepts_diff_0_104_0_rxode2parse, d_accepts_diff_0_104_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_48_0_rxode2parse, d_accepts_diff_0_48_1_rxode2parse +{{d_accepts_diff_0_49_0_rxode2parse, d_accepts_diff_0_49_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_30_0_rxode2parse, d_accepts_diff_0_30_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_206_rxode2parse[3] = { -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_206_0_1_rxode2parse +SB_uint8 d_scanner_227_rxode2parse[3] = { +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_227_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_206_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_206_1_1_rxode2parse +{d_shift_227_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_227_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_206_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_227_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_206_rxode2parse[3] = { +SB_trans_uint8 d_transition_227_rxode2parse[3] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_206_1_1_rxode2parse +{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_227_1_1_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_207_rxode2parse[3] = { -{NULL, {d_scanner_207_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_228_rxode2parse[3] = { +{NULL, {d_scanner_228_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_207_1_rxode2parse, {d_scanner_207_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_228_1_rxode2parse, {d_scanner_228_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_207_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_228_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_207_rxode2parse[3] = { +SB_trans_uint8 d_transition_228_rxode2parse[3] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_207_1_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse +{{d_accepts_diff_228_1_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_209_rxode2parse[8] = { -{NULL, {d_scanner_209_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_230_rxode2parse[8] = { +{NULL, {d_scanner_230_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_63_0_1_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_67_0_1_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_209_2_rxode2parse, {d_scanner_209_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_230_2_rxode2parse, {d_scanner_230_2_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_209_3_rxode2parse, {d_scanner_209_3_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_230_3_rxode2parse, {d_scanner_230_3_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_209_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_230_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_63_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_67_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_209_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_230_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_209_7_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_230_7_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_209_rxode2parse[8] = { +SB_trans_uint8 d_transition_230_rxode2parse[8] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_209_2_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse +{{d_accepts_diff_230_2_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_209_3_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse +{{d_accepts_diff_230_3_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, @@ -5251,16 +5568,16 @@ SB_trans_uint8 d_transition_209_rxode2parse[8] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_210_rxode2parse[3] = { -{NULL, {d_scanner_210_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_231_rxode2parse[3] = { +{NULL, {d_scanner_231_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_71_5_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_78_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_210_rxode2parse[3] = { +SB_trans_uint8 d_transition_231_rxode2parse[3] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5269,16 +5586,16 @@ SB_trans_uint8 d_transition_210_rxode2parse[3] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_211_rxode2parse[3] = { -{NULL, {d_scanner_211_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_232_rxode2parse[3] = { +{NULL, {d_scanner_232_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_211_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_232_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_211_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_232_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_211_rxode2parse[3] = { +SB_trans_uint8 d_transition_232_rxode2parse[3] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5287,18 +5604,18 @@ SB_trans_uint8 d_transition_211_rxode2parse[3] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_223_rxode2parse[4] = { -{NULL, {d_scanner_223_0_0_rxode2parse, d_scanner_223_0_1_rxode2parse +SB_uint8 d_scanner_244_rxode2parse[4] = { +{NULL, {d_scanner_244_0_0_rxode2parse, d_scanner_244_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_223_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_244_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_223_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_244_2_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_223_3_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_244_3_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_223_rxode2parse[4] = { +SB_trans_uint8 d_transition_244_rxode2parse[4] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5309,16 +5626,16 @@ SB_trans_uint8 d_transition_223_rxode2parse[4] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_242_rxode2parse[3] = { -{NULL, {d_scanner_242_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_263_rxode2parse[3] = { +{NULL, {d_scanner_263_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_73_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_80_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_133_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_151_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_242_rxode2parse[3] = { +SB_trans_uint8 d_transition_263_rxode2parse[3] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5327,34 +5644,34 @@ SB_trans_uint8 d_transition_242_rxode2parse[3] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_243_rxode2parse[2] = { -{NULL, {d_scanner_243_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse +SB_uint8 d_scanner_264_rxode2parse[2] = { +{NULL, {d_scanner_264_0_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_243_1_rxode2parse, {d_scanner_243_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_264_1_rxode2parse, {d_scanner_264_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_243_rxode2parse[2] = { +SB_trans_uint8 d_transition_264_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_247_rxode2parse[5] = { -{NULL, {d_scanner_111_0_0_rxode2parse, d_scanner_247_0_1_rxode2parse +SB_uint8 d_scanner_327_rxode2parse[5] = { +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_327_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_247_1_0_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_327_1_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_25_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_327_2_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_63_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_327_3_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_63_6_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_327_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_247_rxode2parse[5] = { +SB_trans_uint8 d_transition_327_rxode2parse[5] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5367,40 +5684,28 @@ SB_trans_uint8 d_transition_247_rxode2parse[5] = { , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_305_rxode2parse[5] = { -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_305_0_1_rxode2parse - , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_305_1_1_rxode2parse +SB_uint8 d_scanner_332_rxode2parse[2] = { +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_332_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_305_2_1_rxode2parse - , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_305_3_1_rxode2parse - , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_305_4_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_332_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_305_rxode2parse[5] = { -{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse - , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse - , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, -{{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse - , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, +SB_trans_uint8 d_transition_332_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}} }; -SB_uint8 d_scanner_310_rxode2parse[2] = { -{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_310_0_1_rxode2parse +SB_uint8 d_scanner_364_rxode2parse[2] = { +{NULL, {d_scanner_0_0_2_rxode2parse, d_scanner_364_0_1_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}}, -{d_shift_310_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse +{d_shift_364_1_rxode2parse, {d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse , d_scanner_0_0_2_rxode2parse, d_scanner_0_0_2_rxode2parse}} }; -SB_trans_uint8 d_transition_310_rxode2parse[2] = { +SB_trans_uint8 d_transition_364_rxode2parse[2] = { {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse , d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse}}, {{d_accepts_diff_0_0_0_rxode2parse, d_accepts_diff_0_0_0_rxode2parse @@ -5408,1038 +5713,1113 @@ SB_trans_uint8 d_transition_310_rxode2parse[2] = { }; unsigned char d_goto_valid_0_rxode2parse[] = { -0xbe,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x85,0x98,0xc4,0x3,0xf,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0xa8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_0_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_0_rxode2parse[] = {{0, 57, &d_reduction_25_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0xbe,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x45,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x1e,0x14,0x62,0x12,0xf,0x3c,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x1,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_0_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_0_rxode2parse[] = {{0, 58, &d_reduction_28_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_1_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_1_rxode2parse[] = {&d_reduction_302_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_1_rxode2parse[] = {{0, 68, &d_reduction_300_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_1_rxode2parse[] = {&d_reduction_323_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_1_rxode2parse[] = {{0, 75, &d_reduction_321_rxode2parse}}; unsigned char d_goto_valid_2_rxode2parse[] = { -0xfe,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x85,0x98,0xc4,0x3,0xf,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0xa8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_2_rxode2parse[] = {&d_reduction_31_rxode2parse,&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_2_rxode2parse[] = {{0, 57, &d_reduction_25_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0xfe,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x45,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x1e,0x14,0x62,0x12,0xf,0x3c,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x1,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_2_rxode2parse[] = {&d_reduction_34_rxode2parse,&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_2_rxode2parse[] = {{0, 58, &d_reduction_28_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_3_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_4_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_5_rxode2parse[] = {&d_reduction_37_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_5_rxode2parse[] = {&d_reduction_40_rxode2parse}; unsigned char d_goto_valid_6_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_7_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_8_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_9_rxode2parse[] = {&d_reduction_64_rxode2parse}; -D_Reduction * d_reductions_10_rxode2parse[] = {&d_reduction_64_rxode2parse}; -D_Reduction * d_reductions_11_rxode2parse[] = {&d_reduction_64_rxode2parse}; -D_Reduction * d_reductions_12_rxode2parse[] = {&d_reduction_64_rxode2parse}; -D_Reduction * d_reductions_13_rxode2parse[] = {&d_reduction_72_rxode2parse}; -D_Reduction * d_reductions_14_rxode2parse[] = {&d_reduction_72_rxode2parse}; -D_Reduction * d_reductions_15_rxode2parse[] = {&d_reduction_72_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_9_rxode2parse[] = {&d_reduction_67_rxode2parse}; +D_Reduction * d_reductions_10_rxode2parse[] = {&d_reduction_67_rxode2parse}; +D_Reduction * d_reductions_11_rxode2parse[] = {&d_reduction_67_rxode2parse}; +D_Reduction * d_reductions_12_rxode2parse[] = {&d_reduction_67_rxode2parse}; +D_Reduction * d_reductions_13_rxode2parse[] = {&d_reduction_75_rxode2parse}; +D_Reduction * d_reductions_14_rxode2parse[] = {&d_reduction_75_rxode2parse}; +D_Reduction * d_reductions_15_rxode2parse[] = {&d_reduction_75_rxode2parse}; unsigned char d_goto_valid_16_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_17_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_18_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_19_rxode2parse[] = {&d_reduction_115_rxode2parse,&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_20_rxode2parse[] = {&d_reduction_115_rxode2parse,&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_21_rxode2parse[] = {&d_reduction_121_rxode2parse,&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_22_rxode2parse[] = {&d_reduction_121_rxode2parse,&d_reduction_262_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_19_rxode2parse[] = {&d_reduction_118_rxode2parse,&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_20_rxode2parse[] = {&d_reduction_118_rxode2parse,&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_21_rxode2parse[] = {&d_reduction_124_rxode2parse,&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_22_rxode2parse[] = {&d_reduction_124_rxode2parse,&d_reduction_280_rxode2parse}; unsigned char d_goto_valid_23_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_23_rxode2parse[] = {&d_reduction_262_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_23_rxode2parse[] = {&d_reduction_280_rxode2parse}; unsigned char d_goto_valid_24_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_24_rxode2parse[] = {&d_reduction_262_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_24_rxode2parse[] = {&d_reduction_280_rxode2parse}; unsigned char d_goto_valid_25_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_26_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_27_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_28_rxode2parse[] = {&d_reduction_295_rxode2parse}; -D_Reduction * d_reductions_29_rxode2parse[] = {&d_reduction_297_rxode2parse}; -unsigned char d_goto_valid_31_rxode2parse[] = { -0xb8,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x85,0x98,0xc4,0x3,0xf,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0xa8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_31_rxode2parse[] = {&d_reduction_1_rxode2parse,&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_31_rxode2parse[] = {{0, 57, &d_reduction_25_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; -D_Reduction * d_reductions_32_rxode2parse[] = {&d_reduction_3_rxode2parse}; -D_Reduction * d_reductions_33_rxode2parse[] = {&d_reduction_4_rxode2parse}; -D_Reduction * d_reductions_34_rxode2parse[] = {&d_reduction_25_rxode2parse}; -D_Reduction * d_reductions_35_rxode2parse[] = {&d_reduction_25_rxode2parse}; -D_Reduction * d_reductions_36_rxode2parse[] = {&d_reduction_25_rxode2parse}; -unsigned char d_goto_valid_37_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_37_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_37_rxode2parse[] = {{0, 85, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_28_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_29_rxode2parse[] = {&d_reduction_316_rxode2parse,&d_reduction_317_rxode2parse}; +D_Reduction * d_reductions_30_rxode2parse[] = {&d_reduction_318_rxode2parse,&d_reduction_319_rxode2parse}; +unsigned char d_goto_valid_32_rxode2parse[] = { +0xb8,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x45,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x1e,0x14,0x62,0x12,0xf,0x3c,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x1,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_32_rxode2parse[] = {&d_reduction_1_rxode2parse,&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_32_rxode2parse[] = {{0, 58, &d_reduction_28_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +D_Reduction * d_reductions_33_rxode2parse[] = {&d_reduction_3_rxode2parse}; +D_Reduction * d_reductions_34_rxode2parse[] = {&d_reduction_4_rxode2parse}; +D_Reduction * d_reductions_35_rxode2parse[] = {&d_reduction_28_rxode2parse}; +D_Reduction * d_reductions_36_rxode2parse[] = {&d_reduction_28_rxode2parse}; +D_Reduction * d_reductions_37_rxode2parse[] = {&d_reduction_28_rxode2parse}; unsigned char d_goto_valid_38_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_38_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_38_rxode2parse[] = {{0, 86, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_38_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_38_rxode2parse[] = {{0, 93, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_39_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_39_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_39_rxode2parse[] = {{0, 87, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_39_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_39_rxode2parse[] = {{0, 94, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_40_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_40_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_40_rxode2parse[] = {{0, 88, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_40_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_40_rxode2parse[] = {{0, 95, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_41_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_41_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_41_rxode2parse[] = {{0, 89, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_41_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_41_rxode2parse[] = {{0, 96, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_42_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_42_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_42_rxode2parse[] = {{0, 97, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_43_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_43_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_43_rxode2parse[] = {{0, 91, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_44_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_44_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_44_rxode2parse[] = {{0, 99, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_45_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_45_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_45_rxode2parse[] = {{0, 93, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_46_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_46_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_46_rxode2parse[] = {{0, 94, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_46_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_46_rxode2parse[] = {{0, 101, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_47_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_47_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_47_rxode2parse[] = {{0, 95, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_47_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_47_rxode2parse[] = {{0, 102, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_48_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_48_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_48_rxode2parse[] = {{0, 96, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_48_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_48_rxode2parse[] = {{0, 103, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_49_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_49_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_49_rxode2parse[] = {{0, 97, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_49_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_49_rxode2parse[] = {{0, 104, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_50_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_50_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_50_rxode2parse[] = {{0, 98, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_50_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_50_rxode2parse[] = {{0, 105, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_51_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_51_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_51_rxode2parse[] = {{0, 99, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_51_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_51_rxode2parse[] = {{0, 106, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_52_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_52_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_52_rxode2parse[] = {{0, 107, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_53_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_53_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_53_rxode2parse[] = {{0, 101, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_54_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_54_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_54_rxode2parse[] = {{0, 109, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_55_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_55_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_55_rxode2parse[] = {{0, 103, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_56_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_56_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_56_rxode2parse[] = {{0, 104, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; -D_Reduction * d_reductions_57_rxode2parse[] = {&d_reduction_25_rxode2parse}; -unsigned char d_goto_valid_58_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_58_rxode2parse[] = {&d_reduction_131_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_56_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_56_rxode2parse[] = {{0, 111, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +unsigned char d_goto_valid_57_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_57_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_57_rxode2parse[] = {{0, 112, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +D_Reduction * d_reductions_58_rxode2parse[] = {&d_reduction_28_rxode2parse}; unsigned char d_goto_valid_59_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_59_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_59_rxode2parse[] = {{0, 107, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_59_rxode2parse[] = {&d_reduction_134_rxode2parse}; unsigned char d_goto_valid_60_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_60_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_60_rxode2parse[] = {{0, 108, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_60_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_60_rxode2parse[] = {{0, 115, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_61_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_61_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_61_rxode2parse[] = {{0, 109, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_61_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_61_rxode2parse[] = {{0, 116, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_62_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_62_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_62_rxode2parse[] = {{0, 110, &d_reduction_5_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_62_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_62_rxode2parse[] = {{0, 117, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; unsigned char d_goto_valid_63_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_64_rxode2parse[] = {&d_reduction_256_rxode2parse}; -D_Reduction * d_reductions_65_rxode2parse[] = {&d_reduction_256_rxode2parse}; -D_Reduction * d_reductions_66_rxode2parse[] = {&d_reduction_256_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_63_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_63_rxode2parse[] = {{0, 118, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +unsigned char d_goto_valid_64_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_64_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_64_rxode2parse[] = {{0, 119, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +unsigned char d_goto_valid_65_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_65_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_65_rxode2parse[] = {{0, 120, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +unsigned char d_goto_valid_66_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_66_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_66_rxode2parse[] = {{0, 121, &d_reduction_5_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +unsigned char d_goto_valid_67_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_68_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18}; -D_Reduction * d_reductions_68_rxode2parse[] = {&d_reduction_300_rxode2parse}; -D_Reduction * d_reductions_69_rxode2parse[] = {&d_reduction_30_rxode2parse}; -unsigned char d_goto_valid_70_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_71_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_71_rxode2parse[] = {&d_reduction_210_rxode2parse}; -unsigned char d_goto_valid_72_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_72_rxode2parse[] = {&d_reduction_210_rxode2parse}; -unsigned char d_goto_valid_73_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_74_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_69_rxode2parse[] = {&d_reduction_274_rxode2parse,&d_reduction_277_rxode2parse}; +D_Reduction * d_reductions_70_rxode2parse[] = {&d_reduction_274_rxode2parse}; +D_Reduction * d_reductions_71_rxode2parse[] = {&d_reduction_277_rxode2parse}; +D_Reduction * d_reductions_72_rxode2parse[] = {&d_reduction_274_rxode2parse}; +D_Reduction * d_reductions_73_rxode2parse[] = {&d_reduction_277_rxode2parse}; unsigned char d_goto_valid_75_rxode2parse[] = { -0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x80,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x40,0x1}; -unsigned char d_goto_valid_76_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_76_rxode2parse[] = {&d_reduction_81_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6}; +D_Reduction * d_reductions_75_rxode2parse[] = {&d_reduction_321_rxode2parse}; +D_Reduction * d_reductions_76_rxode2parse[] = {&d_reduction_33_rxode2parse}; unsigned char d_goto_valid_77_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_78_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_78_rxode2parse[] = {&d_reduction_228_rxode2parse}; unsigned char d_goto_valid_79_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_79_rxode2parse[] = {&d_reduction_228_rxode2parse}; unsigned char d_goto_valid_80_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_81_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_81_rxode2parse[] = {&d_reduction_210_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; unsigned char d_goto_valid_82_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_82_rxode2parse[] = {&d_reduction_210_rxode2parse}; +0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x0,0xa,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x0,0x50,0x0}; unsigned char d_goto_valid_83_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_84_rxode2parse[] = {&d_reduction_2_rxode2parse}; -D_Reduction * d_reductions_85_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_86_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_87_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_88_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_89_rxode2parse[] = {&d_reduction_5_rxode2parse}; +0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_83_rxode2parse[] = {&d_reduction_84_rxode2parse}; +unsigned char d_goto_valid_84_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_85_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_86_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_87_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_88_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_89_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_89_rxode2parse[] = {&d_reduction_228_rxode2parse}; unsigned char d_goto_valid_90_rxode2parse[] = { -0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x80,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_91_rxode2parse[] = {&d_reduction_5_rxode2parse}; -unsigned char d_goto_valid_92_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_90_rxode2parse[] = {&d_reduction_228_rxode2parse}; +unsigned char d_goto_valid_91_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_92_rxode2parse[] = {&d_reduction_2_rxode2parse}; D_Reduction * d_reductions_93_rxode2parse[] = {&d_reduction_5_rxode2parse}; D_Reduction * d_reductions_94_rxode2parse[] = {&d_reduction_5_rxode2parse}; D_Reduction * d_reductions_95_rxode2parse[] = {&d_reduction_5_rxode2parse}; D_Reduction * d_reductions_96_rxode2parse[] = {&d_reduction_5_rxode2parse}; D_Reduction * d_reductions_97_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_98_rxode2parse[] = {&d_reduction_5_rxode2parse}; +unsigned char d_goto_valid_98_rxode2parse[] = { +0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x0,0xa,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x0,0x50,0x0}; D_Reduction * d_reductions_99_rxode2parse[] = {&d_reduction_5_rxode2parse}; unsigned char d_goto_valid_100_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0}; D_Reduction * d_reductions_101_rxode2parse[] = {&d_reduction_5_rxode2parse}; -unsigned char d_goto_valid_102_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; +D_Reduction * d_reductions_102_rxode2parse[] = {&d_reduction_5_rxode2parse}; D_Reduction * d_reductions_103_rxode2parse[] = {&d_reduction_5_rxode2parse}; D_Reduction * d_reductions_104_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_105_rxode2parse[] = {&d_reduction_134_rxode2parse}; -D_Reduction * d_reductions_106_rxode2parse[] = {&d_reduction_132_rxode2parse}; +D_Reduction * d_reductions_105_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_106_rxode2parse[] = {&d_reduction_5_rxode2parse}; D_Reduction * d_reductions_107_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_108_rxode2parse[] = {&d_reduction_5_rxode2parse}; +unsigned char d_goto_valid_108_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; D_Reduction * d_reductions_109_rxode2parse[] = {&d_reduction_5_rxode2parse}; -D_Reduction * d_reductions_110_rxode2parse[] = {&d_reduction_5_rxode2parse}; -unsigned char d_goto_valid_111_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_112_rxode2parse[] = {&d_reduction_89_rxode2parse,&d_reduction_136_rxode2parse}; -D_Reduction * d_reductions_113_rxode2parse[] = {&d_reduction_89_rxode2parse,&d_reduction_136_rxode2parse}; -D_Reduction * d_reductions_114_rxode2parse[] = {&d_reduction_136_rxode2parse}; -unsigned char d_goto_valid_115_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_115_rxode2parse[] = {&d_reduction_248_rxode2parse}; -unsigned char d_goto_valid_116_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_116_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_117_rxode2parse[] = {&d_reduction_303_rxode2parse}; -unsigned char d_goto_valid_118_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20}; -D_Reduction * d_reductions_119_rxode2parse[] = {&d_reduction_301_rxode2parse}; -D_Reduction * d_reductions_120_rxode2parse[] = {&d_reduction_303_rxode2parse}; -D_Reduction * d_reductions_121_rxode2parse[] = {&d_reduction_29_rxode2parse}; +unsigned char d_goto_valid_110_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_111_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_112_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_113_rxode2parse[] = {&d_reduction_137_rxode2parse}; +D_Reduction * d_reductions_114_rxode2parse[] = {&d_reduction_135_rxode2parse}; +D_Reduction * d_reductions_115_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_116_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_117_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_118_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_119_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_120_rxode2parse[] = {&d_reduction_5_rxode2parse}; +D_Reduction * d_reductions_121_rxode2parse[] = {&d_reduction_5_rxode2parse}; unsigned char d_goto_valid_122_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_122_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_123_rxode2parse[] = {&d_reduction_211_rxode2parse}; -D_Reduction * d_reductions_124_rxode2parse[] = {&d_reduction_211_rxode2parse}; -D_Reduction * d_reductions_125_rxode2parse[] = {&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_126_rxode2parse[] = {&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_127_rxode2parse[] = {&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_128_rxode2parse[] = {&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_129_rxode2parse[] = {&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_130_rxode2parse[] = {&d_reduction_262_rxode2parse}; +0x0,0x0,0x0,0x0,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_123_rxode2parse[] = {&d_reduction_92_rxode2parse,&d_reduction_139_rxode2parse}; +D_Reduction * d_reductions_124_rxode2parse[] = {&d_reduction_92_rxode2parse,&d_reduction_139_rxode2parse}; +D_Reduction * d_reductions_125_rxode2parse[] = {&d_reduction_139_rxode2parse}; +unsigned char d_goto_valid_126_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_126_rxode2parse[] = {&d_reduction_266_rxode2parse}; +unsigned char d_goto_valid_127_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_127_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_128_rxode2parse[] = {&d_reduction_143_rxode2parse}; +D_Reduction * d_reductions_129_rxode2parse[] = {&d_reduction_143_rxode2parse}; +D_Reduction * d_reductions_130_rxode2parse[] = {&d_reduction_143_rxode2parse}; unsigned char d_goto_valid_131_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x21,0x28,0x0,0x80,0xa,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_132_rxode2parse[] = {&d_reduction_292_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0}; +D_Reduction * d_reductions_132_rxode2parse[] = {&d_reduction_324_rxode2parse}; unsigned char d_goto_valid_133_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_134_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_134_rxode2parse[] = {&d_reduction_147_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_134_rxode2parse[] = {{0, 206, &d_reduction_145_rxode2parse}}; -unsigned char d_goto_valid_135_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_135_rxode2parse[] = {&d_reduction_153_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_135_rxode2parse[] = {{0, 207, &d_reduction_151_rxode2parse}}; -D_Reduction * d_reductions_136_rxode2parse[] = {&d_reduction_157_rxode2parse}; -D_Reduction * d_reductions_137_rxode2parse[] = {&d_reduction_166_rxode2parse}; -D_Reduction * d_reductions_138_rxode2parse[] = {&d_reduction_166_rxode2parse}; -D_Reduction * d_reductions_139_rxode2parse[] = {&d_reduction_157_rxode2parse}; -unsigned char d_goto_valid_140_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_140_rxode2parse[] = {&d_reduction_176_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_140_rxode2parse[] = {{0, 208, &d_reduction_174_rxode2parse}}; -unsigned char d_goto_valid_141_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_141_rxode2parse[] = {&d_reduction_188_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_141_rxode2parse[] = {{0, 209, &d_reduction_186_rxode2parse}}; -unsigned char d_goto_valid_142_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_142_rxode2parse[] = {&d_reduction_192_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_142_rxode2parse[] = {{0, 210, &d_reduction_190_rxode2parse}}; -unsigned char d_goto_valid_143_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_143_rxode2parse[] = {&d_reduction_198_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_143_rxode2parse[] = {{0, 211, &d_reduction_196_rxode2parse}}; -unsigned char d_goto_valid_144_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x88,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0xc8,0x21,0xec,0xf,0xe8,0xa,0xc,0x0,0x0,0x0,0x0,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x74,0x1}; -D_Reduction * d_reductions_145_rxode2parse[] = {&d_reduction_209_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8}; +D_Reduction * d_reductions_134_rxode2parse[] = {&d_reduction_322_rxode2parse}; +D_Reduction * d_reductions_135_rxode2parse[] = {&d_reduction_324_rxode2parse}; +D_Reduction * d_reductions_136_rxode2parse[] = {&d_reduction_32_rxode2parse}; +unsigned char d_goto_valid_137_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_137_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_138_rxode2parse[] = {&d_reduction_229_rxode2parse}; +D_Reduction * d_reductions_139_rxode2parse[] = {&d_reduction_229_rxode2parse}; +D_Reduction * d_reductions_140_rxode2parse[] = {&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_141_rxode2parse[] = {&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_142_rxode2parse[] = {&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_143_rxode2parse[] = {&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_144_rxode2parse[] = {&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_145_rxode2parse[] = {&d_reduction_280_rxode2parse}; unsigned char d_goto_valid_146_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_147_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_148_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_149_rxode2parse[] = {&d_reduction_38_rxode2parse}; -D_Reduction * d_reductions_150_rxode2parse[] = {&d_reduction_296_rxode2parse}; -D_Reduction * d_reductions_151_rxode2parse[] = {&d_reduction_298_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x21,0x28,0x0,0x0,0x2a,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_147_rxode2parse[] = {&d_reduction_312_rxode2parse}; +D_Reduction * d_reductions_148_rxode2parse[] = {&d_reduction_313_rxode2parse}; +D_Reduction * d_reductions_149_rxode2parse[] = {&d_reduction_316_rxode2parse}; +D_Reduction * d_reductions_150_rxode2parse[] = {&d_reduction_318_rxode2parse}; +unsigned char d_goto_valid_151_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_152_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_153_rxode2parse[] = {&d_reduction_259_rxode2parse}; -D_Reduction * d_reductions_154_rxode2parse[] = {&d_reduction_259_rxode2parse}; -D_Reduction * d_reductions_155_rxode2parse[] = {&d_reduction_259_rxode2parse}; -D_Reduction * d_reductions_156_rxode2parse[] = {&d_reduction_269_rxode2parse,&d_reduction_275_rxode2parse}; -D_Reduction * d_reductions_157_rxode2parse[] = {&d_reduction_269_rxode2parse,&d_reduction_275_rxode2parse}; -D_Reduction * d_reductions_158_rxode2parse[] = {&d_reduction_272_rxode2parse,&d_reduction_275_rxode2parse}; -D_Reduction * d_reductions_159_rxode2parse[] = {&d_reduction_272_rxode2parse,&d_reduction_275_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_152_rxode2parse[] = {&d_reduction_165_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_152_rxode2parse[] = {{0, 227, &d_reduction_163_rxode2parse}}; +unsigned char d_goto_valid_153_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_153_rxode2parse[] = {&d_reduction_171_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_153_rxode2parse[] = {{0, 228, &d_reduction_169_rxode2parse}}; +D_Reduction * d_reductions_154_rxode2parse[] = {&d_reduction_175_rxode2parse}; +D_Reduction * d_reductions_155_rxode2parse[] = {&d_reduction_184_rxode2parse}; +D_Reduction * d_reductions_156_rxode2parse[] = {&d_reduction_184_rxode2parse}; +D_Reduction * d_reductions_157_rxode2parse[] = {&d_reduction_175_rxode2parse}; +unsigned char d_goto_valid_158_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_158_rxode2parse[] = {&d_reduction_194_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_158_rxode2parse[] = {{0, 229, &d_reduction_192_rxode2parse}}; +unsigned char d_goto_valid_159_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_159_rxode2parse[] = {&d_reduction_206_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_159_rxode2parse[] = {{0, 230, &d_reduction_204_rxode2parse}}; unsigned char d_goto_valid_160_rxode2parse[] = { -0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_160_rxode2parse[] = {&d_reduction_42_rxode2parse}; -D_Reduction * d_reductions_161_rxode2parse[] = {&d_reduction_48_rxode2parse}; -D_Reduction * d_reductions_162_rxode2parse[] = {&d_reduction_48_rxode2parse}; -unsigned char d_goto_valid_163_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_164_rxode2parse[] = {&d_reduction_48_rxode2parse}; -unsigned char d_goto_valid_165_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_166_rxode2parse[] = {&d_reduction_48_rxode2parse}; -D_Reduction * d_reductions_167_rxode2parse[] = {&d_reduction_274_rxode2parse}; -D_Reduction * d_reductions_168_rxode2parse[] = {&d_reduction_80_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_160_rxode2parse[] = {&d_reduction_210_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_160_rxode2parse[] = {{0, 231, &d_reduction_208_rxode2parse}}; +unsigned char d_goto_valid_161_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_161_rxode2parse[] = {&d_reduction_216_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_161_rxode2parse[] = {{0, 232, &d_reduction_214_rxode2parse}}; +unsigned char d_goto_valid_162_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x88,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0xc8,0x21,0xec,0xf,0x88,0x2b,0x30,0x0,0x0,0x0,0x0,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x80,0x5c,0x0}; +D_Reduction * d_reductions_163_rxode2parse[] = {&d_reduction_227_rxode2parse}; +unsigned char d_goto_valid_164_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_165_rxode2parse[] = {&d_reduction_274_rxode2parse}; +unsigned char d_goto_valid_166_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_167_rxode2parse[] = {&d_reduction_310_rxode2parse}; +D_Reduction * d_reductions_168_rxode2parse[] = {&d_reduction_310_rxode2parse}; unsigned char d_goto_valid_169_rxode2parse[] = { -0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_169_rxode2parse[] = {&d_reduction_77_rxode2parse}; -unsigned char d_goto_valid_170_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0}; -unsigned char d_goto_valid_171_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_172_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_170_rxode2parse[] = {&d_reduction_41_rxode2parse}; +D_Reduction * d_reductions_171_rxode2parse[] = {&d_reduction_317_rxode2parse}; +D_Reduction * d_reductions_172_rxode2parse[] = {&d_reduction_319_rxode2parse}; unsigned char d_goto_valid_173_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_174_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_175_rxode2parse[] = {&d_reduction_139_rxode2parse}; -D_Reduction * d_reductions_176_rxode2parse[] = {&d_reduction_140_rxode2parse}; -unsigned char d_goto_valid_177_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_178_rxode2parse[] = { -0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_178_rxode2parse[] = {&d_reduction_54_rxode2parse}; -D_Reduction * d_reductions_179_rxode2parse[] = {&d_reduction_60_rxode2parse}; -D_Reduction * d_reductions_180_rxode2parse[] = {&d_reduction_60_rxode2parse}; -D_Reduction * d_reductions_181_rxode2parse[] = {&d_reduction_60_rxode2parse}; -D_Reduction * d_reductions_182_rxode2parse[] = {&d_reduction_60_rxode2parse}; -unsigned char d_goto_valid_183_rxode2parse[] = { -0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_183_rxode2parse[] = {&d_reduction_70_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_174_rxode2parse[] = {&d_reduction_277_rxode2parse}; +D_Reduction * d_reductions_175_rxode2parse[] = {&d_reduction_287_rxode2parse,&d_reduction_293_rxode2parse}; +D_Reduction * d_reductions_176_rxode2parse[] = {&d_reduction_287_rxode2parse,&d_reduction_293_rxode2parse}; +D_Reduction * d_reductions_177_rxode2parse[] = {&d_reduction_290_rxode2parse,&d_reduction_293_rxode2parse}; +D_Reduction * d_reductions_178_rxode2parse[] = {&d_reduction_290_rxode2parse,&d_reduction_293_rxode2parse}; +unsigned char d_goto_valid_179_rxode2parse[] = { +0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_179_rxode2parse[] = {&d_reduction_45_rxode2parse}; +D_Reduction * d_reductions_180_rxode2parse[] = {&d_reduction_51_rxode2parse}; +D_Reduction * d_reductions_181_rxode2parse[] = {&d_reduction_51_rxode2parse}; +unsigned char d_goto_valid_182_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_183_rxode2parse[] = {&d_reduction_51_rxode2parse}; unsigned char d_goto_valid_184_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_185_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_186_rxode2parse[] = {&d_reduction_83_rxode2parse,&d_reduction_86_rxode2parse}; -D_Reduction * d_reductions_187_rxode2parse[] = {&d_reduction_83_rxode2parse,&d_reduction_86_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_185_rxode2parse[] = {&d_reduction_51_rxode2parse}; +D_Reduction * d_reductions_186_rxode2parse[] = {&d_reduction_292_rxode2parse}; +D_Reduction * d_reductions_187_rxode2parse[] = {&d_reduction_83_rxode2parse}; unsigned char d_goto_valid_188_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_188_rxode2parse[] = {&d_reduction_248_rxode2parse}; +0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_188_rxode2parse[] = {&d_reduction_80_rxode2parse}; unsigned char d_goto_valid_189_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_189_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_190_rxode2parse[] = {&d_reduction_247_rxode2parse}; -D_Reduction * d_reductions_191_rxode2parse[] = {&d_reduction_88_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0}; +unsigned char d_goto_valid_190_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_191_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_192_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x34,0x0}; -D_Reduction * d_reductions_193_rxode2parse[] = {&d_reduction_135_rxode2parse}; -D_Reduction * d_reductions_194_rxode2parse[] = {&d_reduction_305_rxode2parse}; -unsigned char d_goto_valid_195_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -unsigned char d_goto_valid_196_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_193_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_194_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_195_rxode2parse[] = {&d_reduction_157_rxode2parse}; +D_Reduction * d_reductions_196_rxode2parse[] = {&d_reduction_158_rxode2parse}; unsigned char d_goto_valid_197_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_198_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_198_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_199_rxode2parse[] = {&d_reduction_244_rxode2parse,&d_reduction_262_rxode2parse}; -D_Reduction * d_reductions_200_rxode2parse[] = {&d_reduction_295_rxode2parse,&d_reduction_299_rxode2parse}; -D_Reduction * d_reductions_201_rxode2parse[] = {&d_reduction_164_rxode2parse}; -unsigned char d_goto_valid_202_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_203_rxode2parse[] = {&d_reduction_164_rxode2parse}; -D_Reduction * d_reductions_204_rxode2parse[] = {&d_reduction_244_rxode2parse}; +0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_198_rxode2parse[] = {&d_reduction_57_rxode2parse}; +D_Reduction * d_reductions_199_rxode2parse[] = {&d_reduction_63_rxode2parse}; +D_Reduction * d_reductions_200_rxode2parse[] = {&d_reduction_63_rxode2parse}; +D_Reduction * d_reductions_201_rxode2parse[] = {&d_reduction_63_rxode2parse}; +D_Reduction * d_reductions_202_rxode2parse[] = {&d_reduction_63_rxode2parse}; +unsigned char d_goto_valid_203_rxode2parse[] = { +0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_203_rxode2parse[] = {&d_reduction_73_rxode2parse}; +unsigned char d_goto_valid_204_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_205_rxode2parse[] = { -0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x85,0x98,0xc4,0x3,0xf,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0xa8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_205_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_205_rxode2parse[] = {{0, 57, &d_reduction_25_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; -unsigned char d_goto_valid_206_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_206_rxode2parse[] = {&d_reduction_145_rxode2parse}; -unsigned char d_goto_valid_207_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_207_rxode2parse[] = {&d_reduction_151_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_206_rxode2parse[] = {&d_reduction_86_rxode2parse,&d_reduction_89_rxode2parse}; +D_Reduction * d_reductions_207_rxode2parse[] = {&d_reduction_86_rxode2parse,&d_reduction_89_rxode2parse}; unsigned char d_goto_valid_208_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_208_rxode2parse[] = {&d_reduction_174_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_208_rxode2parse[] = {&d_reduction_266_rxode2parse}; unsigned char d_goto_valid_209_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_209_rxode2parse[] = {&d_reduction_186_rxode2parse}; -unsigned char d_goto_valid_210_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_210_rxode2parse[] = {&d_reduction_190_rxode2parse}; -unsigned char d_goto_valid_211_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_211_rxode2parse[] = {&d_reduction_196_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_209_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_210_rxode2parse[] = {&d_reduction_265_rxode2parse}; +D_Reduction * d_reductions_211_rxode2parse[] = {&d_reduction_91_rxode2parse}; unsigned char d_goto_valid_212_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_213_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_213_rxode2parse[] = {&d_reduction_210_rxode2parse}; -unsigned char d_goto_valid_214_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_215_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_216_rxode2parse[] = {&d_reduction_291_rxode2parse}; -D_Reduction * d_reductions_217_rxode2parse[] = {&d_reduction_293_rxode2parse}; -D_Reduction * d_reductions_218_rxode2parse[] = {&d_reduction_294_rxode2parse}; -D_Reduction * d_reductions_219_rxode2parse[] = {&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_220_rxode2parse[] = {&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_221_rxode2parse[] = {&d_reduction_203_rxode2parse}; -D_Reduction * d_reductions_222_rxode2parse[] = {&d_reduction_204_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x88,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc,0x0}; +D_Reduction * d_reductions_213_rxode2parse[] = {&d_reduction_138_rxode2parse}; +D_Reduction * d_reductions_214_rxode2parse[] = {&d_reduction_142_rxode2parse}; +D_Reduction * d_reductions_215_rxode2parse[] = {&d_reduction_326_rxode2parse}; +unsigned char d_goto_valid_216_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x0,0xa,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_217_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_218_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_219_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_219_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_220_rxode2parse[] = {&d_reduction_262_rxode2parse,&d_reduction_280_rxode2parse}; +D_Reduction * d_reductions_221_rxode2parse[] = {&d_reduction_316_rxode2parse,&d_reduction_320_rxode2parse}; +D_Reduction * d_reductions_222_rxode2parse[] = {&d_reduction_182_rxode2parse}; unsigned char d_goto_valid_223_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_223_rxode2parse[] = {&d_reduction_204_rxode2parse}; -D_Reduction * d_reductions_224_rxode2parse[] = {&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_225_rxode2parse[] = {&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_226_rxode2parse[] = {&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_227_rxode2parse[] = {&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_228_rxode2parse[] = {&d_reduction_204_rxode2parse,&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_229_rxode2parse[] = {&d_reduction_204_rxode2parse,&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_230_rxode2parse[] = {&d_reduction_204_rxode2parse,&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_231_rxode2parse[] = {&d_reduction_253_rxode2parse}; -D_Reduction * d_reductions_232_rxode2parse[] = {&d_reduction_253_rxode2parse}; -D_Reduction * d_reductions_233_rxode2parse[] = {&d_reduction_253_rxode2parse}; -D_Reduction * d_reductions_234_rxode2parse[] = {&d_reduction_172_rxode2parse}; -D_Reduction * d_reductions_235_rxode2parse[] = {&d_reduction_172_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_224_rxode2parse[] = {&d_reduction_182_rxode2parse}; +D_Reduction * d_reductions_225_rxode2parse[] = {&d_reduction_262_rxode2parse}; +unsigned char d_goto_valid_226_rxode2parse[] = { +0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x45,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x1e,0x14,0x62,0x12,0xf,0x3c,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x1,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_226_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_226_rxode2parse[] = {{0, 58, &d_reduction_28_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +unsigned char d_goto_valid_227_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_227_rxode2parse[] = {&d_reduction_163_rxode2parse}; +unsigned char d_goto_valid_228_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_228_rxode2parse[] = {&d_reduction_169_rxode2parse}; +unsigned char d_goto_valid_229_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_229_rxode2parse[] = {&d_reduction_192_rxode2parse}; +unsigned char d_goto_valid_230_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_230_rxode2parse[] = {&d_reduction_204_rxode2parse}; +unsigned char d_goto_valid_231_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_231_rxode2parse[] = {&d_reduction_208_rxode2parse}; +unsigned char d_goto_valid_232_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_232_rxode2parse[] = {&d_reduction_214_rxode2parse}; +unsigned char d_goto_valid_233_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_234_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_234_rxode2parse[] = {&d_reduction_228_rxode2parse}; +unsigned char d_goto_valid_235_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_236_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0}; -D_Reduction * d_reductions_237_rxode2parse[] = {&d_reduction_169_rxode2parse}; -D_Reduction * d_reductions_238_rxode2parse[] = {&d_reduction_169_rxode2parse}; -unsigned char d_goto_valid_239_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -unsigned char d_goto_valid_240_rxode2parse[] = { -0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x85,0x98,0xc4,0x3,0xf,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0xa8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_240_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_240_rxode2parse[] = {{0, 57, &d_reduction_25_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; -D_Reduction * d_reductions_241_rxode2parse[] = {&d_reduction_39_rxode2parse}; -unsigned char d_goto_valid_242_rxode2parse[] = { -0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_243_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_237_rxode2parse[] = {&d_reduction_309_rxode2parse}; +D_Reduction * d_reductions_238_rxode2parse[] = {&d_reduction_314_rxode2parse}; +D_Reduction * d_reductions_239_rxode2parse[] = {&d_reduction_315_rxode2parse}; +D_Reduction * d_reductions_240_rxode2parse[] = {&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_241_rxode2parse[] = {&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_242_rxode2parse[] = {&d_reduction_221_rxode2parse}; +D_Reduction * d_reductions_243_rxode2parse[] = {&d_reduction_222_rxode2parse}; unsigned char d_goto_valid_244_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0}; -unsigned char d_goto_valid_245_rxode2parse[] = { -0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_246_rxode2parse[] = {&d_reduction_79_rxode2parse}; -unsigned char d_goto_valid_247_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_248_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0xf0,0x3,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x40,0x1}; -unsigned char d_goto_valid_249_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_250_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_251_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_252_rxode2parse[] = { -0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_253_rxode2parse[] = { -0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_254_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_255_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_256_rxode2parse[] = {&d_reduction_82_rxode2parse}; -D_Reduction * d_reductions_257_rxode2parse[] = {&d_reduction_85_rxode2parse}; -D_Reduction * d_reductions_258_rxode2parse[] = {&d_reduction_246_rxode2parse}; -unsigned char d_goto_valid_259_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_260_rxode2parse[] = {&d_reduction_158_rxode2parse}; -D_Reduction * d_reductions_261_rxode2parse[] = {&d_reduction_158_rxode2parse}; -unsigned char d_goto_valid_262_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_244_rxode2parse[] = {&d_reduction_222_rxode2parse}; +D_Reduction * d_reductions_245_rxode2parse[] = {&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_246_rxode2parse[] = {&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_247_rxode2parse[] = {&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_248_rxode2parse[] = {&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_249_rxode2parse[] = {&d_reduction_222_rxode2parse,&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_250_rxode2parse[] = {&d_reduction_222_rxode2parse,&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_251_rxode2parse[] = {&d_reduction_222_rxode2parse,&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_252_rxode2parse[] = {&d_reduction_271_rxode2parse}; +D_Reduction * d_reductions_253_rxode2parse[] = {&d_reduction_271_rxode2parse}; +D_Reduction * d_reductions_254_rxode2parse[] = {&d_reduction_271_rxode2parse}; +D_Reduction * d_reductions_255_rxode2parse[] = {&d_reduction_190_rxode2parse}; +D_Reduction * d_reductions_256_rxode2parse[] = {&d_reduction_190_rxode2parse}; +unsigned char d_goto_valid_257_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0}; +D_Reduction * d_reductions_258_rxode2parse[] = {&d_reduction_187_rxode2parse}; +D_Reduction * d_reductions_259_rxode2parse[] = {&d_reduction_187_rxode2parse}; +unsigned char d_goto_valid_260_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x0,0xa,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_261_rxode2parse[] = { +0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x45,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x1e,0x14,0x62,0x12,0xf,0x3c,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x1,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_261_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_261_rxode2parse[] = {{0, 58, &d_reduction_28_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +D_Reduction * d_reductions_262_rxode2parse[] = {&d_reduction_42_rxode2parse}; unsigned char d_goto_valid_263_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_264_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_264_rxode2parse[] = {&d_reduction_242_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0}; unsigned char d_goto_valid_265_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_266_rxode2parse[] = {&d_reduction_149_rxode2parse}; -D_Reduction * d_reductions_267_rxode2parse[] = {&d_reduction_149_rxode2parse}; -D_Reduction * d_reductions_268_rxode2parse[] = {&d_reduction_146_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0}; +unsigned char d_goto_valid_266_rxode2parse[] = { +0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_267_rxode2parse[] = {&d_reduction_82_rxode2parse}; +unsigned char d_goto_valid_268_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_269_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_269_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_270_rxode2parse[] = {&d_reduction_155_rxode2parse}; -D_Reduction * d_reductions_271_rxode2parse[] = {&d_reduction_155_rxode2parse}; -D_Reduction * d_reductions_272_rxode2parse[] = {&d_reduction_152_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0xf0,0x3,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_270_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_271_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_272_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_273_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_273_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_274_rxode2parse[] = {&d_reduction_178_rxode2parse}; -D_Reduction * d_reductions_275_rxode2parse[] = {&d_reduction_178_rxode2parse}; -D_Reduction * d_reductions_276_rxode2parse[] = {&d_reduction_175_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_274_rxode2parse[] = { +0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_275_rxode2parse[] = { +0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_276_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_277_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x44,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_277_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_278_rxode2parse[] = {&d_reduction_180_rxode2parse}; -D_Reduction * d_reductions_279_rxode2parse[] = {&d_reduction_180_rxode2parse}; -D_Reduction * d_reductions_280_rxode2parse[] = {&d_reduction_180_rxode2parse}; -D_Reduction * d_reductions_281_rxode2parse[] = {&d_reduction_180_rxode2parse}; -D_Reduction * d_reductions_282_rxode2parse[] = {&d_reduction_180_rxode2parse}; -D_Reduction * d_reductions_283_rxode2parse[] = {&d_reduction_180_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_278_rxode2parse[] = {&d_reduction_85_rxode2parse}; +D_Reduction * d_reductions_279_rxode2parse[] = {&d_reduction_88_rxode2parse}; +D_Reduction * d_reductions_280_rxode2parse[] = {&d_reduction_264_rxode2parse}; +unsigned char d_goto_valid_281_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_282_rxode2parse[] = {&d_reduction_176_rxode2parse}; +D_Reduction * d_reductions_283_rxode2parse[] = {&d_reduction_176_rxode2parse}; unsigned char d_goto_valid_284_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x44,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_284_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_285_rxode2parse[] = {&d_reduction_187_rxode2parse}; -D_Reduction * d_reductions_286_rxode2parse[] = {&d_reduction_194_rxode2parse}; -D_Reduction * d_reductions_287_rxode2parse[] = {&d_reduction_194_rxode2parse}; -D_Reduction * d_reductions_288_rxode2parse[] = {&d_reduction_191_rxode2parse}; -unsigned char d_goto_valid_289_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_289_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_290_rxode2parse[] = {&d_reduction_201_rxode2parse}; -D_Reduction * d_reductions_291_rxode2parse[] = {&d_reduction_201_rxode2parse}; -D_Reduction * d_reductions_292_rxode2parse[] = {&d_reduction_197_rxode2parse}; -D_Reduction * d_reductions_293_rxode2parse[] = {&d_reduction_199_rxode2parse}; -unsigned char d_goto_valid_294_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_294_rxode2parse[] = {&d_reduction_210_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_285_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_286_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_286_rxode2parse[] = {&d_reduction_260_rxode2parse}; +unsigned char d_goto_valid_287_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_288_rxode2parse[] = {&d_reduction_167_rxode2parse}; +D_Reduction * d_reductions_289_rxode2parse[] = {&d_reduction_167_rxode2parse}; +D_Reduction * d_reductions_290_rxode2parse[] = {&d_reduction_164_rxode2parse}; +unsigned char d_goto_valid_291_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_291_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_292_rxode2parse[] = {&d_reduction_173_rxode2parse}; +D_Reduction * d_reductions_293_rxode2parse[] = {&d_reduction_173_rxode2parse}; +D_Reduction * d_reductions_294_rxode2parse[] = {&d_reduction_170_rxode2parse}; unsigned char d_goto_valid_295_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_295_rxode2parse[] = {&d_reduction_210_rxode2parse}; -unsigned char d_goto_valid_296_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_297_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -unsigned char d_goto_valid_298_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_299_rxode2parse[] = {&d_reduction_224_rxode2parse}; -D_Reduction * d_reductions_300_rxode2parse[] = {&d_reduction_224_rxode2parse}; -unsigned char d_goto_valid_301_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_301_rxode2parse[] = {&d_reduction_219_rxode2parse}; -D_Reduction * d_reductions_302_rxode2parse[] = {&d_reduction_223_rxode2parse}; -D_Reduction * d_reductions_303_rxode2parse[] = {&d_reduction_171_rxode2parse}; -D_Reduction * d_reductions_304_rxode2parse[] = {&d_reduction_168_rxode2parse}; -unsigned char d_goto_valid_305_rxode2parse[] = { -0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_305_rxode2parse[] = {&d_reduction_35_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_305_rxode2parse[] = {{0, 378, &d_reduction_33_rxode2parse}}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_295_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_296_rxode2parse[] = {&d_reduction_196_rxode2parse}; +D_Reduction * d_reductions_297_rxode2parse[] = {&d_reduction_196_rxode2parse}; +D_Reduction * d_reductions_298_rxode2parse[] = {&d_reduction_193_rxode2parse}; +unsigned char d_goto_valid_299_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x44,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_299_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_300_rxode2parse[] = {&d_reduction_198_rxode2parse}; +D_Reduction * d_reductions_301_rxode2parse[] = {&d_reduction_198_rxode2parse}; +D_Reduction * d_reductions_302_rxode2parse[] = {&d_reduction_198_rxode2parse}; +D_Reduction * d_reductions_303_rxode2parse[] = {&d_reduction_198_rxode2parse}; +D_Reduction * d_reductions_304_rxode2parse[] = {&d_reduction_198_rxode2parse}; +D_Reduction * d_reductions_305_rxode2parse[] = {&d_reduction_198_rxode2parse}; unsigned char d_goto_valid_306_rxode2parse[] = { -0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x80,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_307_rxode2parse[] = {&d_reduction_40_rxode2parse}; -D_Reduction * d_reductions_308_rxode2parse[] = {&d_reduction_41_rxode2parse}; -D_Reduction * d_reductions_309_rxode2parse[] = {&d_reduction_290_rxode2parse}; -unsigned char d_goto_valid_310_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x44,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_306_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_307_rxode2parse[] = {&d_reduction_205_rxode2parse}; +D_Reduction * d_reductions_308_rxode2parse[] = {&d_reduction_212_rxode2parse}; +D_Reduction * d_reductions_309_rxode2parse[] = {&d_reduction_212_rxode2parse}; +D_Reduction * d_reductions_310_rxode2parse[] = {&d_reduction_209_rxode2parse}; unsigned char d_goto_valid_311_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_312_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_312_rxode2parse[] = {&d_reduction_81_rxode2parse}; -D_Reduction * d_reductions_313_rxode2parse[] = {&d_reduction_75_rxode2parse}; -D_Reduction * d_reductions_314_rxode2parse[] = {&d_reduction_76_rxode2parse}; -D_Reduction * d_reductions_315_rxode2parse[] = {&d_reduction_95_rxode2parse}; -D_Reduction * d_reductions_316_rxode2parse[] = {&d_reduction_95_rxode2parse}; -D_Reduction * d_reductions_317_rxode2parse[] = {&d_reduction_95_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_311_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_312_rxode2parse[] = {&d_reduction_219_rxode2parse}; +D_Reduction * d_reductions_313_rxode2parse[] = {&d_reduction_219_rxode2parse}; +D_Reduction * d_reductions_314_rxode2parse[] = {&d_reduction_215_rxode2parse}; +D_Reduction * d_reductions_315_rxode2parse[] = {&d_reduction_217_rxode2parse}; +unsigned char d_goto_valid_316_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_316_rxode2parse[] = {&d_reduction_228_rxode2parse}; +unsigned char d_goto_valid_317_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_317_rxode2parse[] = {&d_reduction_228_rxode2parse}; unsigned char d_goto_valid_318_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_318_rxode2parse[] = {&d_reduction_94_rxode2parse}; -D_Reduction * d_reductions_319_rxode2parse[] = {&d_reduction_280_rxode2parse,&d_reduction_286_rxode2parse}; -D_Reduction * d_reductions_320_rxode2parse[] = {&d_reduction_280_rxode2parse,&d_reduction_286_rxode2parse}; -D_Reduction * d_reductions_321_rxode2parse[] = {&d_reduction_283_rxode2parse,&d_reduction_286_rxode2parse}; -D_Reduction * d_reductions_322_rxode2parse[] = {&d_reduction_283_rxode2parse,&d_reduction_286_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_319_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +unsigned char d_goto_valid_320_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_321_rxode2parse[] = {&d_reduction_242_rxode2parse}; +D_Reduction * d_reductions_322_rxode2parse[] = {&d_reduction_242_rxode2parse}; unsigned char d_goto_valid_323_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_324_rxode2parse[] = {&d_reduction_102_rxode2parse}; -D_Reduction * d_reductions_325_rxode2parse[] = {&d_reduction_102_rxode2parse}; -unsigned char d_goto_valid_326_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_327_rxode2parse[] = {&d_reduction_102_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_323_rxode2parse[] = {&d_reduction_237_rxode2parse}; +D_Reduction * d_reductions_324_rxode2parse[] = {&d_reduction_241_rxode2parse}; +D_Reduction * d_reductions_325_rxode2parse[] = {&d_reduction_189_rxode2parse}; +D_Reduction * d_reductions_326_rxode2parse[] = {&d_reduction_186_rxode2parse}; +unsigned char d_goto_valid_327_rxode2parse[] = { +0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_327_rxode2parse[] = {&d_reduction_38_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_327_rxode2parse[] = {{0, 405, &d_reduction_36_rxode2parse}}; unsigned char d_goto_valid_328_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_329_rxode2parse[] = {&d_reduction_102_rxode2parse}; -D_Reduction * d_reductions_330_rxode2parse[] = {&d_reduction_285_rxode2parse}; -D_Reduction * d_reductions_331_rxode2parse[] = {&d_reduction_124_rxode2parse}; -D_Reduction * d_reductions_332_rxode2parse[] = {&d_reduction_124_rxode2parse}; -D_Reduction * d_reductions_333_rxode2parse[] = {&d_reduction_124_rxode2parse}; +0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x0,0xa,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_329_rxode2parse[] = {&d_reduction_43_rxode2parse}; +D_Reduction * d_reductions_330_rxode2parse[] = {&d_reduction_44_rxode2parse}; +D_Reduction * d_reductions_331_rxode2parse[] = {&d_reduction_308_rxode2parse}; +unsigned char d_goto_valid_332_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_333_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_334_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_334_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_335_rxode2parse[] = {&d_reduction_128_rxode2parse}; -D_Reduction * d_reductions_336_rxode2parse[] = {&d_reduction_128_rxode2parse}; -D_Reduction * d_reductions_337_rxode2parse[] = {&d_reduction_128_rxode2parse}; -unsigned char d_goto_valid_338_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_338_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_339_rxode2parse[] = {&d_reduction_142_rxode2parse}; -D_Reduction * d_reductions_340_rxode2parse[] = {&d_reduction_142_rxode2parse}; -D_Reduction * d_reductions_341_rxode2parse[] = {&d_reduction_142_rxode2parse}; -unsigned char d_goto_valid_342_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_342_rxode2parse[] = {&d_reduction_210_rxode2parse}; -unsigned char d_goto_valid_343_rxode2parse[] = { -0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x80,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_344_rxode2parse[] = {&d_reduction_52_rxode2parse}; -D_Reduction * d_reductions_345_rxode2parse[] = {&d_reduction_53_rxode2parse}; -unsigned char d_goto_valid_346_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_346_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_347_rxode2parse[] = {&d_reduction_68_rxode2parse}; -D_Reduction * d_reductions_348_rxode2parse[] = {&d_reduction_69_rxode2parse}; -D_Reduction * d_reductions_349_rxode2parse[] = {&d_reduction_112_rxode2parse}; -D_Reduction * d_reductions_350_rxode2parse[] = {&d_reduction_112_rxode2parse}; -D_Reduction * d_reductions_351_rxode2parse[] = {&d_reduction_112_rxode2parse}; -unsigned char d_goto_valid_352_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_352_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_353_rxode2parse[] = {&d_reduction_118_rxode2parse}; -D_Reduction * d_reductions_354_rxode2parse[] = {&d_reduction_118_rxode2parse}; -D_Reduction * d_reductions_355_rxode2parse[] = {&d_reduction_118_rxode2parse}; +0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_334_rxode2parse[] = {&d_reduction_84_rxode2parse}; +D_Reduction * d_reductions_335_rxode2parse[] = {&d_reduction_78_rxode2parse}; +D_Reduction * d_reductions_336_rxode2parse[] = {&d_reduction_79_rxode2parse}; +D_Reduction * d_reductions_337_rxode2parse[] = {&d_reduction_98_rxode2parse}; +D_Reduction * d_reductions_338_rxode2parse[] = {&d_reduction_98_rxode2parse}; +D_Reduction * d_reductions_339_rxode2parse[] = {&d_reduction_98_rxode2parse}; +unsigned char d_goto_valid_340_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_340_rxode2parse[] = {&d_reduction_97_rxode2parse}; +D_Reduction * d_reductions_341_rxode2parse[] = {&d_reduction_298_rxode2parse,&d_reduction_304_rxode2parse}; +D_Reduction * d_reductions_342_rxode2parse[] = {&d_reduction_298_rxode2parse,&d_reduction_304_rxode2parse}; +D_Reduction * d_reductions_343_rxode2parse[] = {&d_reduction_301_rxode2parse,&d_reduction_304_rxode2parse}; +D_Reduction * d_reductions_344_rxode2parse[] = {&d_reduction_301_rxode2parse,&d_reduction_304_rxode2parse}; +unsigned char d_goto_valid_345_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_346_rxode2parse[] = {&d_reduction_105_rxode2parse}; +D_Reduction * d_reductions_347_rxode2parse[] = {&d_reduction_105_rxode2parse}; +unsigned char d_goto_valid_348_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_349_rxode2parse[] = {&d_reduction_105_rxode2parse}; +unsigned char d_goto_valid_350_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_351_rxode2parse[] = {&d_reduction_105_rxode2parse}; +D_Reduction * d_reductions_352_rxode2parse[] = {&d_reduction_303_rxode2parse}; +D_Reduction * d_reductions_353_rxode2parse[] = {&d_reduction_127_rxode2parse}; +D_Reduction * d_reductions_354_rxode2parse[] = {&d_reduction_127_rxode2parse}; +D_Reduction * d_reductions_355_rxode2parse[] = {&d_reduction_127_rxode2parse}; unsigned char d_goto_valid_356_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_356_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_357_rxode2parse[] = {&d_reduction_159_rxode2parse}; -D_Reduction * d_reductions_358_rxode2parse[] = {&d_reduction_159_rxode2parse}; -D_Reduction * d_reductions_359_rxode2parse[] = {&d_reduction_159_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_356_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_357_rxode2parse[] = {&d_reduction_131_rxode2parse}; +D_Reduction * d_reductions_358_rxode2parse[] = {&d_reduction_131_rxode2parse}; +D_Reduction * d_reductions_359_rxode2parse[] = {&d_reduction_131_rxode2parse}; unsigned char d_goto_valid_360_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x12,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_360_rxode2parse[] = {&d_reduction_210_rxode2parse,&d_reduction_239_rxode2parse}; -unsigned char d_goto_valid_361_rxode2parse[] = { -0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x85,0x98,0xc4,0x3,0xf,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0xa8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_361_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_361_rxode2parse[] = {{0, 57, &d_reduction_25_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; -D_Reduction * d_reductions_362_rxode2parse[] = {&d_reduction_148_rxode2parse}; -D_Reduction * d_reductions_363_rxode2parse[] = {&d_reduction_154_rxode2parse}; -D_Reduction * d_reductions_364_rxode2parse[] = {&d_reduction_177_rxode2parse}; -D_Reduction * d_reductions_365_rxode2parse[] = {&d_reduction_189_rxode2parse}; -D_Reduction * d_reductions_366_rxode2parse[] = {&d_reduction_193_rxode2parse}; -D_Reduction * d_reductions_367_rxode2parse[] = {&d_reduction_200_rxode2parse}; -unsigned char d_goto_valid_368_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_369_rxode2parse[] = {&d_reduction_235_rxode2parse}; +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_360_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_361_rxode2parse[] = {&d_reduction_150_rxode2parse,&d_reduction_154_rxode2parse}; +D_Reduction * d_reductions_362_rxode2parse[] = {&d_reduction_150_rxode2parse,&d_reduction_154_rxode2parse}; +D_Reduction * d_reductions_363_rxode2parse[] = {&d_reduction_150_rxode2parse,&d_reduction_154_rxode2parse}; +unsigned char d_goto_valid_364_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_365_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0}; +D_Reduction * d_reductions_366_rxode2parse[] = {&d_reduction_160_rxode2parse}; +D_Reduction * d_reductions_367_rxode2parse[] = {&d_reduction_160_rxode2parse}; +D_Reduction * d_reductions_368_rxode2parse[] = {&d_reduction_160_rxode2parse}; +unsigned char d_goto_valid_369_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_369_rxode2parse[] = {&d_reduction_228_rxode2parse}; unsigned char d_goto_valid_370_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_371_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_372_rxode2parse[] = {&d_reduction_220_rxode2parse}; -D_Reduction * d_reductions_373_rxode2parse[] = {&d_reduction_220_rxode2parse}; -D_Reduction * d_reductions_374_rxode2parse[] = {&d_reduction_222_rxode2parse}; -unsigned char d_goto_valid_375_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x88,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc1,0x21,0xec,0xf,0xe8,0xa,0xc,0x0,0x0,0x0,0x0,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x74,0x1}; -D_Reduction * d_reductions_376_rxode2parse[] = {&d_reduction_218_rxode2parse}; -unsigned char d_goto_valid_377_rxode2parse[] = { -0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x80,0x2,0x85,0x98,0xc4,0x3,0xf,0x0,0x1,0x8,0x60,0x30,0x8,0x2,0xa8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_377_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_377_rxode2parse[] = {{0, 57, &d_reduction_25_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; -D_Reduction * d_reductions_378_rxode2parse[] = {&d_reduction_33_rxode2parse}; -D_Reduction * d_reductions_379_rxode2parse[] = {&d_reduction_34_rxode2parse}; -D_Reduction * d_reductions_380_rxode2parse[] = {&d_reduction_43_rxode2parse}; -D_Reduction * d_reductions_381_rxode2parse[] = {&d_reduction_44_rxode2parse}; -D_Reduction * d_reductions_382_rxode2parse[] = {&d_reduction_44_rxode2parse}; -D_Reduction * d_reductions_383_rxode2parse[] = {&d_reduction_44_rxode2parse}; -D_Reduction * d_reductions_384_rxode2parse[] = {&d_reduction_44_rxode2parse}; -D_Reduction * d_reductions_385_rxode2parse[] = {&d_reduction_268_rxode2parse}; -D_Reduction * d_reductions_386_rxode2parse[] = {&d_reduction_271_rxode2parse}; -D_Reduction * d_reductions_387_rxode2parse[] = {&d_reduction_78_rxode2parse}; -D_Reduction * d_reductions_388_rxode2parse[] = {&d_reduction_92_rxode2parse}; -D_Reduction * d_reductions_389_rxode2parse[] = {&d_reduction_92_rxode2parse}; -unsigned char d_goto_valid_390_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_390_rxode2parse[] = {&d_reduction_210_rxode2parse}; -unsigned char d_goto_valid_391_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_392_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0}; -unsigned char d_goto_valid_393_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0}; -D_Reduction * d_reductions_394_rxode2parse[] = {&d_reduction_123_rxode2parse}; -D_Reduction * d_reductions_395_rxode2parse[] = {&d_reduction_127_rxode2parse}; -D_Reduction * d_reductions_396_rxode2parse[] = {&d_reduction_141_rxode2parse}; -D_Reduction * d_reductions_397_rxode2parse[] = {&d_reduction_55_rxode2parse}; -D_Reduction * d_reductions_398_rxode2parse[] = {&d_reduction_56_rxode2parse}; -D_Reduction * d_reductions_399_rxode2parse[] = {&d_reduction_56_rxode2parse}; -D_Reduction * d_reductions_400_rxode2parse[] = {&d_reduction_56_rxode2parse}; -D_Reduction * d_reductions_401_rxode2parse[] = {&d_reduction_56_rxode2parse}; -D_Reduction * d_reductions_402_rxode2parse[] = {&d_reduction_71_rxode2parse}; -D_Reduction * d_reductions_403_rxode2parse[] = {&d_reduction_111_rxode2parse}; -D_Reduction * d_reductions_404_rxode2parse[] = {&d_reduction_117_rxode2parse}; -D_Reduction * d_reductions_405_rxode2parse[] = {&d_reduction_243_rxode2parse}; -unsigned char d_goto_valid_406_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x50,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_407_rxode2parse[] = {&d_reduction_241_rxode2parse}; -unsigned char d_goto_valid_408_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_409_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_409_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_410_rxode2parse[] = {&d_reduction_98_rxode2parse}; -unsigned char d_goto_valid_411_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0xf0,0x3,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x0,0x40,0x1}; -D_Reduction * d_reductions_412_rxode2parse[] = {&d_reduction_213_rxode2parse}; -D_Reduction * d_reductions_413_rxode2parse[] = {&d_reduction_214_rxode2parse}; -D_Reduction * d_reductions_414_rxode2parse[] = {&d_reduction_214_rxode2parse,&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_415_rxode2parse[] = {&d_reduction_214_rxode2parse,&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_416_rxode2parse[] = {&d_reduction_214_rxode2parse,&d_reduction_226_rxode2parse}; -D_Reduction * d_reductions_417_rxode2parse[] = {&d_reduction_36_rxode2parse}; -D_Reduction * d_reductions_418_rxode2parse[] = {&d_reduction_91_rxode2parse}; -D_Reduction * d_reductions_419_rxode2parse[] = {&d_reduction_100_rxode2parse}; -D_Reduction * d_reductions_420_rxode2parse[] = {&d_reduction_100_rxode2parse}; -unsigned char d_goto_valid_421_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_421_rxode2parse[] = {&d_reduction_210_rxode2parse}; -unsigned char d_goto_valid_422_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0}; +0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0xf,0x0,0xa,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_371_rxode2parse[] = {&d_reduction_55_rxode2parse}; +D_Reduction * d_reductions_372_rxode2parse[] = {&d_reduction_56_rxode2parse}; +unsigned char d_goto_valid_373_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_373_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_374_rxode2parse[] = {&d_reduction_71_rxode2parse}; +D_Reduction * d_reductions_375_rxode2parse[] = {&d_reduction_72_rxode2parse}; +D_Reduction * d_reductions_376_rxode2parse[] = {&d_reduction_115_rxode2parse}; +D_Reduction * d_reductions_377_rxode2parse[] = {&d_reduction_115_rxode2parse}; +D_Reduction * d_reductions_378_rxode2parse[] = {&d_reduction_115_rxode2parse}; +unsigned char d_goto_valid_379_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_379_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_380_rxode2parse[] = {&d_reduction_121_rxode2parse}; +D_Reduction * d_reductions_381_rxode2parse[] = {&d_reduction_121_rxode2parse}; +D_Reduction * d_reductions_382_rxode2parse[] = {&d_reduction_121_rxode2parse}; +unsigned char d_goto_valid_383_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_383_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_384_rxode2parse[] = {&d_reduction_177_rxode2parse}; +D_Reduction * d_reductions_385_rxode2parse[] = {&d_reduction_177_rxode2parse}; +D_Reduction * d_reductions_386_rxode2parse[] = {&d_reduction_177_rxode2parse}; +unsigned char d_goto_valid_387_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x12,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_387_rxode2parse[] = {&d_reduction_228_rxode2parse,&d_reduction_257_rxode2parse}; +unsigned char d_goto_valid_388_rxode2parse[] = { +0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x45,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x1e,0x14,0x62,0x12,0xf,0x3c,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x1,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_388_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_388_rxode2parse[] = {{0, 58, &d_reduction_28_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +D_Reduction * d_reductions_389_rxode2parse[] = {&d_reduction_166_rxode2parse}; +D_Reduction * d_reductions_390_rxode2parse[] = {&d_reduction_172_rxode2parse}; +D_Reduction * d_reductions_391_rxode2parse[] = {&d_reduction_195_rxode2parse}; +D_Reduction * d_reductions_392_rxode2parse[] = {&d_reduction_207_rxode2parse}; +D_Reduction * d_reductions_393_rxode2parse[] = {&d_reduction_211_rxode2parse}; +D_Reduction * d_reductions_394_rxode2parse[] = {&d_reduction_218_rxode2parse}; +unsigned char d_goto_valid_395_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_396_rxode2parse[] = {&d_reduction_253_rxode2parse}; +unsigned char d_goto_valid_397_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_398_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_399_rxode2parse[] = {&d_reduction_238_rxode2parse}; +D_Reduction * d_reductions_400_rxode2parse[] = {&d_reduction_238_rxode2parse}; +D_Reduction * d_reductions_401_rxode2parse[] = {&d_reduction_240_rxode2parse}; +unsigned char d_goto_valid_402_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x88,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc1,0x21,0xec,0xf,0x88,0x2b,0x30,0x0,0x0,0x0,0x0,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x80,0x5c,0x0}; +D_Reduction * d_reductions_403_rxode2parse[] = {&d_reduction_236_rxode2parse}; +unsigned char d_goto_valid_404_rxode2parse[] = { +0xb0,0x79,0x8,0x33,0x54,0x11,0xda,0x5a,0x45,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x1e,0x14,0x62,0x12,0xf,0x3c,0x0,0x4,0x20,0x80,0xc1,0x20,0x8,0x0,0x1,0x0,0x15,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_404_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_404_rxode2parse[] = {{0, 58, &d_reduction_28_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +D_Reduction * d_reductions_405_rxode2parse[] = {&d_reduction_36_rxode2parse}; +D_Reduction * d_reductions_406_rxode2parse[] = {&d_reduction_37_rxode2parse}; +D_Reduction * d_reductions_407_rxode2parse[] = {&d_reduction_46_rxode2parse}; +D_Reduction * d_reductions_408_rxode2parse[] = {&d_reduction_47_rxode2parse}; +D_Reduction * d_reductions_409_rxode2parse[] = {&d_reduction_47_rxode2parse}; +D_Reduction * d_reductions_410_rxode2parse[] = {&d_reduction_47_rxode2parse}; +D_Reduction * d_reductions_411_rxode2parse[] = {&d_reduction_47_rxode2parse}; +D_Reduction * d_reductions_412_rxode2parse[] = {&d_reduction_286_rxode2parse}; +D_Reduction * d_reductions_413_rxode2parse[] = {&d_reduction_289_rxode2parse}; +D_Reduction * d_reductions_414_rxode2parse[] = {&d_reduction_81_rxode2parse}; +D_Reduction * d_reductions_415_rxode2parse[] = {&d_reduction_95_rxode2parse}; +D_Reduction * d_reductions_416_rxode2parse[] = {&d_reduction_95_rxode2parse}; +unsigned char d_goto_valid_417_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_417_rxode2parse[] = {&d_reduction_228_rxode2parse}; +unsigned char d_goto_valid_418_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_419_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0}; +unsigned char d_goto_valid_420_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0}; +D_Reduction * d_reductions_421_rxode2parse[] = {&d_reduction_126_rxode2parse}; +D_Reduction * d_reductions_422_rxode2parse[] = {&d_reduction_130_rxode2parse}; unsigned char d_goto_valid_423_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_424_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_424_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_425_rxode2parse[] = {&d_reduction_237_rxode2parse}; -D_Reduction * d_reductions_426_rxode2parse[] = {&d_reduction_238_rxode2parse}; -unsigned char d_goto_valid_427_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_427_rxode2parse[] = {&d_reduction_133_rxode2parse}; -D_RightEpsilonHint d_right_epsilon_hints_427_rxode2parse[] = {{0, 438, &d_reduction_32_rxode2parse},{0, 58, &d_reduction_131_rxode2parse}}; -unsigned char d_goto_valid_428_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -unsigned char d_goto_valid_429_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_430_rxode2parse[] = {&d_reduction_107_rxode2parse}; -D_Reduction * d_reductions_431_rxode2parse[] = {&d_reduction_107_rxode2parse}; -D_Reduction * d_reductions_432_rxode2parse[] = {&d_reduction_107_rxode2parse}; -D_Reduction * d_reductions_433_rxode2parse[] = {&d_reduction_107_rxode2parse}; -D_Reduction * d_reductions_434_rxode2parse[] = {&d_reduction_99_rxode2parse}; -D_Reduction * d_reductions_435_rxode2parse[] = {&d_reduction_279_rxode2parse}; -D_Reduction * d_reductions_436_rxode2parse[] = {&d_reduction_282_rxode2parse}; -D_Reduction * d_reductions_437_rxode2parse[] = {&d_reduction_240_rxode2parse}; -D_Reduction * d_reductions_438_rxode2parse[] = {&d_reduction_32_rxode2parse}; -unsigned char d_goto_valid_439_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x90,0x2,0x8,0x0,0x0,0x0,0x80,0x0,0x40,0x0,0x60,0x30,0x8,0x2,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x1}; -D_Reduction * d_reductions_439_rxode2parse[] = {&d_reduction_210_rxode2parse}; -D_Reduction * d_reductions_440_rxode2parse[] = {&d_reduction_106_rxode2parse}; -unsigned char d_goto_valid_441_rxode2parse[] = { -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; -D_Reduction * d_reductions_442_rxode2parse[] = {&d_reduction_236_rxode2parse}; -unsigned short d_gotos_rxode2parse[4524] = { -31,32,33,34,35,72,36,37,68,69,38,39,40,41,73,74, -75,76,42,77,78,79,80,43,44,81,82,45,46,83,84,86, -59,47,91,48,93,49,101,50,87,59,103,51,88,59,89,59, -52,107,53,54,122,55,56,150,57,195,58,59,206,60,184,61, -62,63,90,59,92,59,94,59,95,59,96,59,97,59,98,59, -99,59,100,59,102,59,104,59,105,59,108,59,109,59,110,59, -111,59,153,154,207,208,209,210,211,170,171,172,154,192,193,212, -189,241,190,242,120,121,155,243,156,116,64,244,65,245,246,155, -237,156,240,247,173,154,248,249,250,251,252,253,254,255,66,256, -67,117,257,193,261,262,265,3,155,4,156,273,274,296,5,298, -259,299,6,7,269,270,8,277,278,9,309,304,358,10,11,12, -13,232,311,233,234,359,191,14,15,16,17,289,290,302,303,285, -335,312,286,126,127,360,315,18,361,362,128,129,126,127,293,294, -295,130,19,128,129,370,386,131,343,387,130,191,20,21,346,392, -131,393,394,22,23,126,127,410,411,391,24,106,128,129,412,428, -25,436,437,130,440,368,441,145,146,131,26,319,27,423,28,70, -32,33,34,35,71,36,37,161,169,38,39,40,41,133,187,188, -424,42,112,113,114,443,43,44,339,349,45,46,422,357,287,115, -47,0,48,353,49,0,50,439,59,0,51,279,0,288,0,52, -0,53,54,0,55,56,307,57,308,58,59,0,60,0,61,62, -63,118,119,313,151,314,152,235,236,332,333,238,239,151,0,152, -0,124,217,388,171,334,340,341,271,272,0,174,154,29,0,30, -125,0,342,267,268,344,151,345,152,0,0,275,276,427,0,155, -162,156,65,163,164,165,166,167,168,64,133,65,0,300,301,389, -217,310,218,219,66,0,67,280,281,282,283,0,284,66,390,67, -310,0,316,317,291,292,3,425,4,426,347,0,348,5,318,336, -337,6,7,379,380,8,0,0,9,354,355,338,10,11,12,13, -420,421,350,351,0,356,14,15,16,17,0,0,126,127,352,375, -367,376,377,128,129,144,18,145,146,0,130,0,310,0,0,0, -131,19,126,127,0,0,0,0,0,128,129,20,21,0,0,310, -130,0,22,23,0,0,131,0,0,24,0,0,85,34,35,25, -36,37,169,0,38,39,40,41,260,26,65,27,42,28,0,0, -0,43,44,0,0,45,46,0,0,0,0,47,66,48,67,49, -0,50,0,0,0,51,0,373,0,0,52,0,53,54,0,55, -56,124,57,0,58,59,374,60,0,61,62,63,0,0,0,0, -125,0,0,0,0,0,157,158,0,0,159,160,378,151,134,152, -0,0,135,0,0,0,136,137,138,0,139,0,140,0,0,0, -0,141,0,29,142,30,0,0,143,0,126,127,29,144,30,145, -146,128,129,0,64,0,65,0,130,0,0,0,0,0,131,0, -0,0,0,0,0,147,0,65,66,0,67,0,0,0,0,0, -0,3,0,4,0,0,148,0,5,66,0,67,6,7,0,0, -8,0,0,9,0,123,0,10,11,12,13,0,0,0,0,0, -0,14,15,16,17,0,0,0,0,0,149,175,154,0,135,178, -154,18,136,137,138,0,139,0,140,124,0,0,19,141,0,155, -142,156,0,155,143,156,20,21,125,144,0,145,146,22,23,0, -0,0,0,0,24,0,0,126,127,0,25,29,0,30,128,129, -0,147,0,65,26,130,27,0,28,0,0,131,0,0,0,0, -0,0,148,0,0,66,0,67,0,0,0,0,0,0,0,0, -0,123,0,0,0,132,0,0,0,0,0,0,126,127,0,0, -126,127,0,128,129,0,0,128,129,0,130,0,0,0,130,365, -131,0,142,0,131,124,143,0,0,0,0,144,0,145,146,0, -0,0,0,0,125,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,126,127,0,0,29,0,30,128,129,0,0,0,0, -0,130,0,0,0,133,0,131,29,176,30,0,0,135,0,0, -0,136,137,138,0,139,0,140,0,366,0,0,141,143,0,142, -0,132,144,143,145,146,0,0,144,0,145,146,0,0,179,0, -0,0,0,0,0,0,0,124,0,0,0,0,0,151,0,152, -147,151,65,152,177,0,125,0,135,0,0,0,136,137,138,0, -139,148,140,0,66,0,67,141,185,154,142,0,186,154,143,0, -123,0,0,144,0,145,146,0,0,0,0,0,155,0,156,0, -155,133,156,0,29,0,30,0,0,0,0,147,0,65,124,0, -0,0,0,0,124,0,0,0,0,0,0,0,148,125,0,66, -0,67,180,125,65,181,164,182,166,183,168,123,0,0,0,0, -0,0,126,127,0,0,66,0,67,128,129,0,0,0,0,0, -130,0,371,154,0,0,131,0,0,126,127,0,0,126,127,124, -128,129,0,0,128,129,155,130,156,0,0,130,0,131,125,0, -132,131,0,0,0,0,0,0,0,0,0,0,0,126,127,0, -0,0,0,0,128,129,0,0,0,0,0,130,0,0,0,0, -0,131,0,0,126,127,0,0,0,0,0,128,129,0,0,0, -197,138,130,139,0,198,0,0,131,0,141,132,0,142,0,0, -0,143,202,126,127,0,144,203,145,146,128,129,0,204,0,65, -133,130,0,29,0,30,0,131,0,0,0,0,0,0,147,0, -65,66,0,67,0,205,0,0,0,0,151,0,152,199,151,148, -152,0,66,0,67,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,157,158,0,133,159,160,29,0, -30,0,0,194,0,0,0,135,0,0,0,136,137,138,0,139, -0,140,124,0,0,29,141,30,0,142,0,0,0,143,0,126, -127,125,144,0,145,146,128,200,0,0,0,0,0,130,0,0, -126,127,0,131,151,0,152,128,129,0,147,0,65,0,130,0, -0,0,0,0,131,0,0,0,0,0,0,148,0,0,66,0, -67,0,0,263,138,0,139,0,264,0,123,0,0,141,196,0, -142,0,0,0,143,0,0,0,0,144,0,145,146,0,0,0, -0,0,0,0,0,0,0,0,0,220,0,0,0,221,124,0, -0,147,0,65,305,0,65,0,0,0,0,0,0,125,0,0, -0,0,148,0,0,66,0,67,66,0,67,0,126,127,0,0, -201,0,30,128,129,0,0,0,0,0,130,0,0,0,133,0, -131,29,222,30,0,0,0,0,0,223,0,0,224,225,226,0, -0,372,154,203,0,124,0,0,227,228,132,65,229,164,230,166, -231,168,0,0,125,155,0,156,0,232,0,233,234,66,0,67, -0,205,0,126,127,0,126,127,213,214,128,129,0,128,129,0, -0,130,0,0,130,0,0,131,0,0,131,0,0,0,0,0, +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_424_rxode2parse[] = {&d_reduction_153_rxode2parse}; +D_Reduction * d_reductions_425_rxode2parse[] = {&d_reduction_159_rxode2parse}; +D_Reduction * d_reductions_426_rxode2parse[] = {&d_reduction_58_rxode2parse}; +D_Reduction * d_reductions_427_rxode2parse[] = {&d_reduction_59_rxode2parse}; +D_Reduction * d_reductions_428_rxode2parse[] = {&d_reduction_59_rxode2parse}; +D_Reduction * d_reductions_429_rxode2parse[] = {&d_reduction_59_rxode2parse}; +D_Reduction * d_reductions_430_rxode2parse[] = {&d_reduction_59_rxode2parse}; +D_Reduction * d_reductions_431_rxode2parse[] = {&d_reduction_74_rxode2parse}; +D_Reduction * d_reductions_432_rxode2parse[] = {&d_reduction_114_rxode2parse}; +D_Reduction * d_reductions_433_rxode2parse[] = {&d_reduction_120_rxode2parse}; +D_Reduction * d_reductions_434_rxode2parse[] = {&d_reduction_261_rxode2parse}; +unsigned char d_goto_valid_435_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x40,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_436_rxode2parse[] = {&d_reduction_259_rxode2parse}; +unsigned char d_goto_valid_437_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_438_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_438_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_439_rxode2parse[] = {&d_reduction_101_rxode2parse}; +unsigned char d_goto_valid_440_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0xf0,0x3,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc,0x0,0x0,0x50,0x0}; +D_Reduction * d_reductions_441_rxode2parse[] = {&d_reduction_231_rxode2parse}; +D_Reduction * d_reductions_442_rxode2parse[] = {&d_reduction_232_rxode2parse}; +D_Reduction * d_reductions_443_rxode2parse[] = {&d_reduction_232_rxode2parse,&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_444_rxode2parse[] = {&d_reduction_232_rxode2parse,&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_445_rxode2parse[] = {&d_reduction_232_rxode2parse,&d_reduction_244_rxode2parse}; +D_Reduction * d_reductions_446_rxode2parse[] = {&d_reduction_39_rxode2parse}; +D_Reduction * d_reductions_447_rxode2parse[] = {&d_reduction_94_rxode2parse}; +D_Reduction * d_reductions_448_rxode2parse[] = {&d_reduction_103_rxode2parse}; +D_Reduction * d_reductions_449_rxode2parse[] = {&d_reduction_103_rxode2parse}; +unsigned char d_goto_valid_450_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_450_rxode2parse[] = {&d_reduction_228_rxode2parse}; +unsigned char d_goto_valid_451_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_452_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_453_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0}; +unsigned char d_goto_valid_454_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_454_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_455_rxode2parse[] = {&d_reduction_255_rxode2parse}; +D_Reduction * d_reductions_456_rxode2parse[] = {&d_reduction_256_rxode2parse}; +unsigned char d_goto_valid_457_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_457_rxode2parse[] = {&d_reduction_136_rxode2parse}; +D_RightEpsilonHint d_right_epsilon_hints_457_rxode2parse[] = {{0, 469, &d_reduction_35_rxode2parse},{0, 59, &d_reduction_134_rxode2parse}}; +unsigned char d_goto_valid_458_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_459_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_460_rxode2parse[] = {&d_reduction_110_rxode2parse}; +D_Reduction * d_reductions_461_rxode2parse[] = {&d_reduction_110_rxode2parse}; +D_Reduction * d_reductions_462_rxode2parse[] = {&d_reduction_110_rxode2parse}; +D_Reduction * d_reductions_463_rxode2parse[] = {&d_reduction_110_rxode2parse}; +D_Reduction * d_reductions_464_rxode2parse[] = {&d_reduction_102_rxode2parse}; +D_Reduction * d_reductions_465_rxode2parse[] = {&d_reduction_297_rxode2parse}; +D_Reduction * d_reductions_466_rxode2parse[] = {&d_reduction_300_rxode2parse}; +unsigned char d_goto_valid_467_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +D_Reduction * d_reductions_467_rxode2parse[] = {&d_reduction_148_rxode2parse}; +D_Reduction * d_reductions_468_rxode2parse[] = {&d_reduction_258_rxode2parse}; +D_Reduction * d_reductions_469_rxode2parse[] = {&d_reduction_35_rxode2parse}; +unsigned char d_goto_valid_470_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x71,0x85,0x44,0x68,0x0,0x0,0x28,0x0,0x70,0xa,0x20,0x0,0x0,0x0,0x0,0x2,0x0,0x1,0x80,0xc1,0x20,0x8,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x53,0x0}; +D_Reduction * d_reductions_470_rxode2parse[] = {&d_reduction_228_rxode2parse}; +D_Reduction * d_reductions_471_rxode2parse[] = {&d_reduction_109_rxode2parse}; +unsigned char d_goto_valid_472_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_473_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; +unsigned char d_goto_valid_474_rxode2parse[] = { +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0}; +D_Reduction * d_reductions_475_rxode2parse[] = {&d_reduction_146_rxode2parse}; +D_Reduction * d_reductions_476_rxode2parse[] = {&d_reduction_147_rxode2parse}; +D_Reduction * d_reductions_477_rxode2parse[] = {&d_reduction_254_rxode2parse}; +D_Reduction * d_reductions_478_rxode2parse[] = {&d_reduction_149_rxode2parse}; +unsigned short d_gotos_rxode2parse[4771] = { +32,33,34,35,36,79,37,38,75,76,39,40,41,42,80,81, +82,83,43,84,85,86,87,44,45,88,89,46,47,90,91,92, +99,48,101,49,109,50,111,51,94,60,132,52,95,60,96,60, +53,115,54,55,137,56,57,171,58,216,59,60,227,61,228,62, +229,63,97,60,230,64,231,65,66,67,98,60,100,60,102,60, +103,60,104,60,105,60,106,60,107,60,108,60,110,60,112,60, +113,60,116,60,117,60,118,60,119,60,120,60,121,60,122,60, +232,135,136,174,175,189,190,204,168,169,212,213,233,209,262,210, +263,258,68,69,70,215,168,169,261,72,264,74,265,266,267,268, +269,127,270,271,272,273,274,275,71,72,73,74,276,277,278,283, +284,3,287,4,279,213,295,296,5,128,291,292,6,7,318,320, +8,321,331,9,129,130,333,10,11,12,13,299,300,337,281,385, +131,14,15,16,17,211,324,325,326,168,169,311,312,334,386,253, +357,18,387,254,255,341,141,142,388,370,389,373,19,143,144,361, +397,315,316,317,145,413,20,21,414,419,146,406,407,22,23,211, +418,420,421,307,24,114,308,424,380,439,25,415,190,440,441,452, +454,458,376,466,453,467,471,26,77,33,34,35,36,78,37,38, +180,472,39,40,41,42,473,27,478,28,43,29,470,60,188,44, +45,0,0,46,47,207,208,0,365,48,366,49,0,50,0,51, +309,0,0,52,123,124,125,0,53,0,54,55,0,56,57,310, +58,126,59,60,335,61,336,62,329,63,330,0,0,64,0,65, +66,67,133,134,0,0,0,0,0,367,368,148,149,256,257,0, +0,301,451,354,355,369,259,260,384,148,149,172,371,173,372,356, +358,359,0,238,0,0,338,339,293,294,457,30,360,31,289,290, +0,181,340,166,182,183,184,185,186,187,68,69,70,374,405,375, +416,377,378,0,297,298,477,71,0,73,332,322,323,379,0,417, +71,72,73,74,188,0,455,0,456,3,0,4,148,149,362,363, +5,332,0,238,6,7,239,240,8,0,364,9,313,314,0,10, +11,12,13,402,0,403,404,0,0,14,15,16,17,0,0,0, +302,303,304,305,393,306,0,0,161,18,0,392,0,162,160,163, +164,0,161,332,19,141,142,162,332,163,164,0,143,144,20,21, +425,168,169,145,0,22,23,0,475,146,476,0,24,0,381,382, +449,450,25,0,395,0,163,164,0,0,383,0,0,0,0,26, +93,35,36,0,37,38,0,0,39,40,41,42,0,400,0,27, +43,28,0,29,0,44,45,0,0,46,47,0,401,0,0,48, +0,49,0,50,0,51,0,0,0,52,0,139,0,0,53,0, +54,55,0,56,57,139,58,0,59,60,140,61,0,62,0,63, +0,0,0,64,140,65,66,67,0,0,0,0,176,177,0,0, +178,179,139,468,168,169,0,0,0,0,152,0,0,0,153,0, +0,140,154,155,156,0,157,0,158,0,150,0,151,159,0,0, +160,191,175,30,161,31,0,0,0,162,0,163,164,0,0,0, +68,69,70,479,168,169,0,72,0,74,0,0,0,0,0,0, +0,165,0,166,0,0,71,72,73,74,0,0,0,0,0,3, +0,4,167,168,169,0,5,71,394,73,6,7,0,162,8,163, +164,9,0,138,0,10,11,12,13,0,0,0,0,0,0,14, +15,16,17,0,148,149,0,0,0,192,175,0,0,0,0,18, +0,0,0,0,141,142,0,139,193,175,19,143,144,0,0,72, +0,74,145,0,20,21,140,0,146,194,175,22,23,0,72,0, +74,0,24,0,0,141,142,0,25,0,0,0,143,144,0,72, +0,74,0,145,0,26,0,0,170,146,0,139,153,195,175,0, +154,155,156,0,157,27,158,28,0,29,140,159,0,0,160,0, +0,0,161,72,0,74,0,162,0,163,164,0,141,142,0,198, +175,0,0,143,144,0,147,148,149,0,145,141,142,0,0,165, +146,166,143,144,0,72,0,74,0,145,0,0,141,142,0,146, +167,168,169,143,144,71,0,73,0,0,145,0,0,0,0,0, +146,138,0,0,0,0,0,148,149,172,0,173,0,0,0,0, +141,142,0,0,0,0,0,143,144,30,0,31,0,0,145,0, +0,0,0,0,146,139,148,149,0,0,150,0,151,0,0,0, +0,0,141,142,140,0,0,0,0,143,144,0,0,0,0,0, +145,0,0,141,142,0,146,0,0,0,143,144,0,0,0,0, +0,145,196,0,0,0,153,146,0,0,154,155,156,0,157,0, +158,172,0,173,0,159,0,0,160,0,0,0,161,0,0,0, +172,162,173,163,164,0,0,0,199,0,0,0,0,0,0,0, +0,172,0,173,147,0,0,0,0,165,0,166,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,167,168,169,0,0,71, +0,73,205,175,0,172,0,173,0,197,0,138,0,153,0,0, +0,154,155,156,0,157,0,158,72,0,74,0,159,0,0,160, +0,206,175,161,0,0,0,172,162,173,163,164,0,0,0,139, +0,0,0,0,148,149,0,72,150,74,151,0,0,0,140,0, +165,0,166,0,200,0,166,201,183,202,185,203,187,141,142,0, +0,167,168,169,143,144,71,0,73,0,71,145,73,0,0,0, +0,146,138,0,0,141,142,0,0,0,0,0,143,144,0,0, +0,0,0,145,0,0,0,0,0,146,0,0,0,0,0,0, +0,0,0,0,141,142,139,0,0,0,0,143,144,0,147,0, +0,0,145,0,0,140,0,0,146,0,0,0,0,0,0,0, +0,0,0,0,141,142,0,0,141,142,0,143,144,0,0,143, +144,0,145,0,0,214,145,0,146,153,0,0,146,154,155,156, +0,157,0,158,0,0,0,0,159,0,0,160,0,0,0,161, +0,0,0,0,162,0,163,164,0,0,0,0,0,0,148,149, +0,0,150,0,151,147,0,0,0,0,0,0,165,0,166,0, +0,0,0,0,0,0,0,0,0,0,172,0,173,167,168,169, +0,0,71,0,73,0,0,0,0,0,223,0,0,0,138,224, +0,0,0,0,0,225,0,166,0,172,0,173,0,0,0,176, +177,0,0,178,179,0,0,0,0,0,0,71,0,73,0,226, +0,0,139,0,0,148,149,220,0,150,0,151,0,150,0,151, +0,140,0,398,175,0,0,0,0,0,0,0,0,0,0,0, +141,142,0,0,0,0,0,143,144,72,0,74,218,156,145,157, +0,219,0,0,146,0,159,0,0,160,241,0,0,161,242,0, +0,0,162,0,163,164,0,0,0,141,142,0,0,0,0,0, +143,221,0,0,0,0,0,145,0,0,165,0,166,146,0,0, +0,147,0,0,282,0,166,0,0,0,0,167,168,169,0,0, +71,0,73,0,0,0,141,142,0,0,71,243,73,143,144,0, +0,0,244,0,145,245,246,247,0,327,146,166,224,0,0,0, +0,248,249,0,166,250,183,251,185,252,187,0,0,0,0,71, +139,73,253,0,0,0,254,255,71,0,73,0,226,0,0,140, +0,148,149,234,235,150,0,151,0,0,0,0,0,0,141,142, +0,0,0,0,0,143,144,0,141,142,0,0,145,0,0,143, +144,0,146,0,0,0,145,0,0,0,0,0,146,0,222,0, +151,236,0,0,0,0,0,0,0,0,0,0,237,141,142,0, +0,0,0,0,143,144,141,142,0,0,0,145,0,143,221,217, +0,146,0,0,145,0,0,0,0,0,146,172,0,173,0,280, +0,0,0,153,0,0,0,154,155,156,0,157,0,158,0,0, +0,0,159,0,0,160,0,0,0,161,0,0,399,175,162,0, +163,164,0,0,285,156,0,157,0,286,0,0,0,0,159,0, +0,160,72,0,74,161,165,0,166,0,162,0,163,164,0,148, +149,0,0,150,0,151,0,167,168,169,0,0,71,150,73,151, +0,0,165,0,166,0,0,0,138,0,0,0,0,176,177,0, +0,178,179,167,168,169,0,0,71,0,73,0,0,0,0,0, +0,0,150,0,151,0,238,0,0,239,240,222,139,151,0,141, +142,0,0,0,0,0,143,144,0,0,0,140,0,145,0,0, +0,0,0,146,0,0,0,0,139,0,141,142,0,0,0,0, +0,143,144,0,0,0,0,140,145,0,0,408,0,0,146,0, +0,0,0,0,0,0,141,142,0,0,0,0,0,143,144,288, +36,0,37,38,145,0,39,40,41,42,146,0,0,0,43,0, +0,0,0,44,45,0,0,46,47,0,0,147,0,48,0,49, +0,50,0,51,0,0,0,52,0,0,0,0,53,0,54,55, +0,56,57,0,58,0,59,60,0,61,0,62,0,63,0,0, +0,64,0,65,66,67,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,172,0,173,0,0,0,0,0,0,409,0,166, +410,183,411,185,412,187,0,0,0,0,0,148,149,0,0,150, +0,151,0,71,0,73,0,0,0,0,0,0,0,0,68,69, +70,0,0,0,0,0,0,148,149,0,427,150,0,151,0,0, +0,0,0,0,71,72,73,74,0,0,0,0,0,3,0,4, +0,0,0,0,5,0,0,0,6,7,0,0,8,0,0,9, +0,0,0,10,11,12,13,0,0,0,0,0,0,14,15,16, +17,141,142,0,0,0,0,0,143,144,0,0,0,18,0,145, +0,0,319,0,0,146,153,0,19,0,154,155,156,0,157,0, +158,0,20,21,0,159,0,0,160,22,23,0,161,0,0,0, +24,162,0,163,164,0,25,428,0,166,429,183,430,185,431,187, +0,0,0,26,0,0,0,0,0,165,0,166,0,71,0,73, +0,0,0,27,0,28,0,29,0,0,167,168,169,0,0,71, +0,73,0,0,0,0,0,0,0,0,0,138,0,0,0,0, +0,0,0,0,0,0,0,0,176,177,0,0,178,179,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,139, +0,0,0,0,0,0,150,0,151,0,0,141,142,0,140,0, +0,0,143,144,0,0,0,0,0,145,0,0,0,141,142,146, +0,0,0,0,143,144,0,30,0,31,0,145,0,0,0,0, +0,146,0,0,0,0,0,328,36,346,37,38,0,0,39,40, +41,42,0,0,0,0,43,0,0,0,0,44,45,0,0,46, +47,0,0,0,0,48,0,49,0,50,0,51,0,0,147,52, +0,0,0,0,53,0,54,55,0,56,57,0,58,0,59,60, +0,61,0,62,0,63,0,0,0,64,0,65,66,67,0,0, +0,0,176,177,0,0,178,179,0,0,0,0,0,0,0,347, +175,0,0,0,0,0,0,348,349,350,351,352,353,0,0,0, +150,0,151,0,0,72,0,74,0,0,0,0,0,0,148,149, +0,0,150,0,151,0,68,69,70,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,71,72,73,74, +0,0,0,0,0,3,0,4,0,0,0,0,5,0,0,0, +6,7,0,0,8,0,0,9,0,0,0,10,11,12,13,0, +0,0,141,142,0,14,15,16,17,143,144,0,0,0,0,0, +145,0,0,0,0,18,146,0,0,0,0,0,0,0,0,0, +19,0,0,0,0,0,0,0,0,0,20,21,0,0,0,0, +0,22,23,0,0,0,0,0,24,0,0,390,0,0,25,154, +155,156,0,157,0,158,0,0,0,0,159,26,0,160,0,0, +0,161,0,0,0,0,162,0,163,164,0,27,0,28,0,29, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,165,0, +166,0,0,0,0,0,0,0,0,342,343,0,0,344,345,167, +168,169,0,0,71,0,73,0,0,0,0,0,0,0,0,0, +138,0,0,0,0,0,0,172,0,173,0,0,391,155,156,0, +157,0,158,0,0,0,0,159,0,0,160,0,0,0,161,0, +0,0,0,162,139,163,164,0,0,0,0,0,0,0,0,30, +0,31,0,140,0,0,0,0,0,0,0,165,0,166,0,0, +0,0,141,142,0,0,0,0,0,143,144,0,167,168,169,0, +145,71,0,73,0,0,146,0,0,0,0,396,0,138,0,153, +0,0,0,154,155,156,0,157,0,158,0,0,0,0,159,0, +0,160,0,0,0,161,0,0,0,0,162,0,163,164,0,0, +0,139,0,147,0,0,0,0,0,0,0,0,0,0,0,0, +140,0,165,0,166,0,0,0,0,0,0,0,0,0,0,141, +142,0,0,167,168,169,143,144,71,0,73,0,0,145,0,0, +0,0,0,146,138,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,215,0,0,0,133,0,0,29,0,30, -0,216,126,127,0,0,0,0,0,128,129,126,127,0,0,0, -130,0,128,200,258,0,131,0,135,130,0,0,136,137,138,131, -139,0,140,0,0,0,0,141,0,0,142,0,0,0,143,0, -0,0,0,144,0,145,146,0,0,0,0,0,0,0,0,0, -0,133,0,0,29,0,30,29,0,30,0,147,0,65,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,148,0,0,66, -0,67,0,0,0,0,0,0,0,0,0,123,0,0,0,157, -158,0,0,159,160,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,151,0,152,0,0,217,0,218,219,201,0,30,124, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,125,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,126,127,266, -35,0,36,37,128,129,38,39,40,41,0,130,0,0,42,0, -0,131,0,43,44,0,0,45,46,0,0,0,0,47,0,48, -0,49,0,50,0,0,0,51,0,0,0,132,52,0,53,54, -0,55,56,0,57,0,58,59,0,60,0,61,62,63,0,0, +0,0,0,148,149,0,0,150,139,151,422,0,0,0,153,0, +147,0,154,155,156,0,157,140,158,0,0,0,0,159,0,0, +160,0,0,0,161,0,141,142,0,162,0,163,164,143,144,0, +0,0,0,0,145,0,0,0,0,0,146,0,0,0,0,0, +0,165,0,166,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,167,168,169,0,0,71,0,73,0,0,0,0,0,0, +148,149,0,138,150,0,151,147,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,423,0,0,0,153,0,0,0, +154,155,156,0,157,0,158,139,0,0,0,159,0,0,160,0, +0,0,161,0,0,0,140,162,0,163,164,0,0,0,0,0, +0,0,460,0,0,141,142,0,0,0,0,0,143,144,0,165, +0,166,0,145,0,0,0,148,149,146,0,150,0,151,0,0, +167,168,169,0,0,71,0,73,0,0,0,0,0,0,0,426, +0,138,0,153,0,0,0,154,155,156,0,157,0,158,0,0, +0,0,159,0,0,160,147,0,0,161,0,0,0,0,162,0, +163,164,0,0,0,139,461,175,0,0,0,0,0,0,462,349, +463,351,464,353,140,0,165,0,166,0,0,0,72,0,74,0, +0,0,0,141,142,0,0,167,168,169,143,144,71,0,73,0, +0,145,0,0,0,0,0,146,138,0,0,0,0,0,0,0, +0,0,0,0,0,0,148,149,0,0,150,0,151,432,0,0, +0,153,0,0,0,154,155,156,0,157,0,158,139,0,0,0, +159,0,0,160,147,0,0,161,0,141,142,140,162,0,163,164, +143,144,0,0,0,0,0,145,0,0,141,142,0,146,0,0, +0,143,144,0,165,0,166,0,145,0,0,0,0,0,146,0, +0,0,0,0,0,167,168,169,0,0,71,0,73,0,0,0, +0,0,0,0,0,0,138,0,0,0,0,0,0,0,0,0, +0,0,0,0,148,149,0,0,150,0,151,147,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,139,0,433,0,0,0, +153,0,0,0,154,155,156,0,157,140,158,0,0,0,0,159, +342,343,160,0,344,345,161,0,141,142,0,162,0,163,164,143, +144,0,0,0,0,0,145,0,0,0,0,0,146,0,172,0, +173,0,0,165,0,166,0,0,0,0,0,148,149,0,0,150, +0,151,0,0,167,168,169,0,0,71,0,73,0,0,0,0, +0,0,0,434,0,138,0,153,0,147,0,154,155,156,0,157, +0,158,0,0,0,0,159,0,0,160,0,0,0,161,0,0, +0,0,162,0,163,164,0,0,0,139,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,140,0,165,0,166,0,0,0, +0,0,0,0,0,0,0,141,142,0,0,167,168,169,143,144, +71,0,73,0,0,145,0,0,0,148,149,146,138,150,0,151, +435,0,0,0,153,0,0,0,154,155,156,0,157,0,158,0, +0,0,0,159,0,0,160,0,0,0,161,0,0,0,0,162, +139,163,164,0,0,0,0,0,147,0,0,0,0,436,0,140, +437,0,0,0,0,0,0,165,0,166,0,0,0,0,141,142, +0,0,0,0,0,143,144,0,167,168,169,0,145,71,0,73, +0,0,146,0,0,0,0,0,0,138,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -297,0,0,0,135,0,0,0,136,137,138,0,139,0,140,0, -0,0,0,141,0,0,142,0,0,0,143,0,0,0,0,144, -0,145,146,0,0,0,64,0,65,0,0,133,0,0,29,0, -30,0,0,0,0,0,0,147,0,65,66,0,67,0,0,0, -0,0,0,3,0,4,0,0,148,0,5,66,0,67,6,7, -0,0,8,0,0,9,0,123,0,10,11,12,13,0,0,0, -0,0,0,14,15,16,17,0,0,0,0,0,0,0,0,0, -0,0,0,18,0,0,0,0,0,0,0,124,0,0,19,0, -0,0,0,0,0,0,0,0,20,21,125,0,0,0,0,22, -23,0,0,0,0,0,24,0,0,126,127,0,25,0,0,0, -128,129,0,0,0,0,26,130,27,0,28,306,35,131,36,37, -0,0,38,39,40,41,0,0,0,0,42,0,0,0,0,43, -44,0,0,45,46,0,0,132,0,47,0,48,0,49,0,50, -324,0,0,51,0,0,0,0,52,0,53,54,0,55,56,0, -57,0,58,59,0,60,0,61,62,63,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,148,149,0,0,150,139,151,147, +0,0,0,0,0,0,0,0,0,0,0,0,140,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,141,142,0,0,0, +0,0,143,144,0,0,0,0,0,145,0,0,0,0,0,146, +0,0,0,0,0,0,0,0,0,438,36,0,37,38,0,0, +39,40,41,42,0,0,0,0,43,0,0,0,0,44,45,148, +149,46,47,150,0,151,0,48,0,49,0,50,147,51,0,0, +0,52,0,0,0,0,53,0,54,55,0,56,57,0,58,0, +59,60,0,61,0,62,0,63,0,0,0,64,0,65,66,67, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,29,0,30,0,0,0,0, -0,0,0,0,0,0,0,133,0,0,29,0,30,0,325,154, -0,0,64,0,65,0,326,327,328,329,330,331,0,0,0,0, -0,0,155,0,156,0,66,0,67,0,0,0,0,0,0,3, -0,4,0,0,0,0,5,0,0,0,6,7,0,0,8,0, -0,9,0,0,0,10,11,12,13,0,0,0,0,0,0,14, -15,16,17,0,0,0,0,0,0,0,0,0,0,0,0,18, -0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,126, -127,0,0,0,20,21,128,129,0,0,0,22,23,130,0,0, -0,0,24,131,0,0,363,0,25,0,136,137,138,0,139,0, -140,0,26,0,27,141,28,0,142,0,0,0,143,0,0,0, -0,144,0,145,146,0,0,0,0,0,0,0,364,137,138,0, -139,0,140,0,0,0,0,141,0,147,142,65,0,0,143,0, -0,0,0,144,0,145,146,0,0,0,148,0,0,66,0,67, -0,0,0,320,321,0,0,322,323,123,0,147,0,65,0,0, -0,0,0,0,0,0,0,0,0,381,0,0,148,0,0,66, -151,67,152,0,0,29,0,30,0,0,0,123,0,124,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,125,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,126,127,0,0,124, -0,0,128,129,0,0,0,0,0,130,0,0,0,369,125,131, -0,135,0,0,0,136,137,138,0,139,0,140,0,126,127,0, -141,0,0,142,128,129,0,143,0,132,0,130,144,0,145,146, -0,131,0,382,0,65,383,164,384,166,385,168,0,0,0,0, -0,0,0,0,147,0,65,66,0,67,0,132,0,0,0,0, -0,0,0,0,0,148,0,0,66,0,67,0,0,0,0,0, -0,0,0,0,123,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,133,0,0,29,0,30,0, -0,0,0,0,0,0,0,0,124,0,0,0,0,0,0,0, -0,0,0,0,0,126,127,125,0,0,0,133,128,129,29,0, -30,0,0,130,0,0,126,127,0,131,0,0,0,128,129,0, -0,0,0,0,130,0,0,395,0,0,131,135,0,0,0,136, -137,138,0,139,0,140,0,0,0,0,141,0,0,142,0,0, -0,143,0,396,132,0,144,135,145,146,0,136,137,138,0,139, -0,140,0,0,0,0,141,0,0,142,0,0,0,143,147,0, -65,0,144,0,145,146,0,0,0,157,158,0,0,159,160,148, -0,0,66,0,67,0,0,0,0,0,147,0,65,0,123,0, -0,0,0,0,0,0,29,0,30,0,0,148,0,0,66,0, -67,0,0,0,133,0,0,29,0,30,123,0,0,0,0,0, -0,0,124,0,0,0,0,0,0,0,0,0,0,0,398,0, -0,125,0,0,0,0,0,0,0,0,0,0,0,0,124,0, -126,127,0,0,0,0,0,128,129,0,0,0,0,125,130,0, -0,0,0,0,131,0,0,0,0,0,0,0,126,127,0,0, -0,0,0,128,129,0,0,0,0,0,130,0,0,397,132,0, -131,135,0,0,0,136,137,138,0,139,0,140,0,0,0,0, -141,0,0,142,0,0,0,143,0,0,132,0,144,0,145,146, -0,0,0,399,0,65,400,164,401,166,402,168,0,0,0,0, -0,0,0,0,147,0,65,66,0,67,0,0,0,0,0,0, -0,0,0,0,0,148,0,0,66,0,67,0,0,0,133,0, -0,29,0,30,123,0,0,0,403,0,0,0,135,0,0,0, -136,137,138,0,139,0,140,0,0,0,133,141,0,29,142,30, -0,0,143,0,0,0,0,144,124,145,146,0,0,0,0,0, -0,0,0,0,0,126,127,125,0,0,0,0,128,129,0,147, -0,65,0,130,0,0,126,127,0,131,0,0,0,128,129,0, -148,0,0,66,130,67,0,0,0,0,131,0,0,0,0,123, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,132,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,124,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,125,0,0,0,0,0,0,157,158,0,0,159,160,0, -0,126,127,0,0,0,0,0,128,129,0,0,0,0,0,130, -0,0,0,0,0,131,29,404,30,0,0,135,0,0,0,136, -137,138,0,139,133,140,0,29,0,30,141,0,0,142,0,132, -0,143,0,405,0,0,144,135,145,146,0,136,137,138,0,139, -430,140,0,0,0,0,141,0,0,142,0,0,0,143,147,0, -65,0,144,0,145,146,0,0,0,0,0,0,0,0,0,148, -0,0,66,0,67,0,0,0,0,0,147,0,65,0,123,0, -0,0,0,0,0,0,0,0,0,0,0,148,0,0,66,133, -67,0,29,0,30,0,0,0,0,0,123,0,431,154,0,0, -0,0,124,0,432,327,433,329,434,331,0,0,0,0,0,0, -155,125,156,0,0,0,0,0,0,0,0,0,0,0,124,0, -126,127,0,0,0,0,0,128,129,0,0,0,0,125,130,0, -0,0,0,0,131,0,0,0,0,0,0,0,126,127,0,0, -0,0,0,128,129,0,0,0,0,0,130,0,0,406,132,0, -131,135,0,0,0,136,137,138,0,139,0,140,0,126,127,0, -141,0,0,142,128,129,0,143,0,0,132,130,144,0,145,146, -0,131,0,0,0,0,0,0,0,0,407,0,0,408,0,0, -0,0,0,0,147,0,65,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,148,0,0,66,0,67,0,0,0,133,0, -0,29,0,30,123,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,133,0,0,29,0,30, -0,320,321,0,0,322,323,0,124,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,125,0,0,0,0,0,0,151,0, -152,0,0,0,0,0,126,127,409,35,0,36,37,128,129,38, -39,40,41,0,130,0,0,42,0,0,131,0,43,44,0,0, -45,46,0,0,0,0,47,0,48,0,49,0,50,0,0,0, -51,0,0,0,132,52,0,53,54,0,55,56,0,57,0,58, -59,0,60,0,61,62,63,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,148,149,0,0, +150,0,151,0,0,0,0,0,68,69,70,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,71,72, +73,74,0,0,0,0,0,3,0,4,0,0,241,0,5,0, +242,0,6,7,0,0,8,0,0,9,0,0,0,10,11,12, +13,0,0,0,0,0,0,14,15,16,17,0,0,0,0,0, +0,0,0,0,0,0,0,18,0,0,0,0,0,0,0,0, +0,0,19,0,0,0,0,0,0,0,0,0,20,21,0,0, +0,442,0,22,23,0,0,443,246,247,24,0,0,0,224,0, +25,0,0,248,249,0,166,444,183,445,185,446,187,26,0,0, +0,0,0,0,253,0,0,0,254,255,71,0,73,27,226,28, +0,29,0,0,0,234,235,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,64, -0,65,0,0,133,0,0,29,0,30,0,0,0,0,0,0, -0,0,0,66,0,67,0,0,0,0,0,0,3,0,4,0, -0,0,0,5,0,0,0,6,7,0,0,8,0,0,9,0, -0,0,10,11,12,13,220,0,0,0,221,0,14,15,16,17, -0,0,0,0,0,0,0,0,0,0,0,0,18,0,0,0, -0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0, -0,20,21,0,0,0,0,0,22,23,0,0,0,0,0,24, -0,0,0,413,0,25,0,0,0,414,225,226,0,0,0,26, -203,27,0,28,0,227,228,0,65,415,164,416,166,417,168,0, -0,0,0,0,0,0,232,0,233,234,66,0,67,0,205,0, -0,0,0,0,0,213,214,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,236,0,0,0,0,0,0,0,0,0,0,237,0, +0,0,0,0,0,0,0,0,141,142,0,0,0,0,0,143, +221,447,36,0,37,38,145,0,39,40,41,42,146,0,0,0, +43,30,0,31,0,44,45,0,0,46,47,0,0,0,0,48, +0,49,0,50,0,51,0,0,0,52,0,0,0,0,53,0, +54,55,0,56,57,0,58,0,59,60,0,61,0,62,0,63, +0,0,0,64,0,65,66,67,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,215,0,0,0,0,0,0,0,0,0,0,216,0, -0,0,29,0,30,0,0,0,126,127,418,35,0,36,37,128, -200,38,39,40,41,0,130,0,0,42,0,0,131,0,43,44, -0,0,45,46,0,0,0,0,47,0,48,0,49,0,50,0, -0,0,51,0,0,0,0,52,0,53,54,0,55,56,0,57, -0,58,59,0,60,0,61,62,63,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,157,158,0,0, -159,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,64,0,65,0,217,0,218,219,201,0,30,0,0,0,0, -0,0,0,0,0,66,0,67,0,0,0,0,0,0,3,0, -4,0,0,0,0,5,0,0,0,6,7,0,0,8,0,0, -9,0,0,0,10,11,12,13,0,0,0,0,0,0,14,15, -16,17,0,0,0,0,0,419,0,0,0,135,0,0,18,136, -137,138,0,139,0,140,0,0,0,19,141,0,0,142,0,0, -0,143,0,20,21,0,144,0,145,146,22,23,0,0,0,0, -0,24,0,0,0,0,0,25,0,0,0,0,0,0,147,0, -65,26,429,27,0,28,135,0,0,0,136,137,138,0,139,148, -140,0,66,0,67,141,0,0,142,0,0,0,143,0,123,0, -0,144,0,145,146,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,147,0,65,0,0,0,0, -0,0,124,0,0,0,0,0,0,0,148,0,0,66,0,67, -0,125,0,0,0,0,0,0,0,123,0,0,0,0,0,0, -126,127,0,0,29,0,30,128,129,0,0,0,0,0,130,0, -0,0,0,0,131,0,0,0,0,0,0,0,0,124,0,0, -0,0,0,0,0,0,0,0,0,0,0,435,125,0,132,135, -0,0,0,136,137,138,0,139,0,140,0,126,127,0,141,0, -0,142,128,129,0,143,0,0,0,130,144,0,145,146,0,131, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,176, +177,0,0,178,179,0,0,0,0,0,0,0,0,0,0,0, +68,69,70,0,0,0,0,0,238,0,0,239,240,222,0,151, +0,0,0,0,0,0,71,72,73,74,0,0,0,0,0,3, +0,4,0,0,0,0,5,0,0,0,6,7,0,0,8,0, +0,9,0,0,0,10,11,12,13,0,0,0,0,0,0,14, +15,16,17,0,0,0,0,0,0,0,0,0,0,0,0,18, +0,0,0,0,448,0,0,0,153,0,19,0,154,155,156,0, +157,0,158,0,20,21,0,159,0,0,160,22,23,0,161,0, +0,0,24,162,0,163,164,0,25,0,0,0,0,0,0,0, +0,0,0,0,0,26,0,0,0,0,0,165,0,166,0,0, +0,0,0,0,0,27,0,28,0,29,0,0,167,168,169,0, +0,71,0,73,0,0,0,0,0,0,0,459,0,138,0,153, +0,0,0,154,155,156,0,157,0,158,0,0,0,0,159,0, +0,160,0,0,0,161,0,0,0,0,162,0,163,164,0,0, +0,139,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +140,0,165,0,166,0,0,0,0,0,0,0,0,0,0,141, +142,0,0,167,168,169,143,144,71,30,73,31,0,145,0,0, +0,0,465,146,138,0,153,0,0,0,154,155,156,0,157,0, +158,0,0,0,0,159,0,0,160,0,0,0,161,0,0,0, +0,162,0,163,164,0,0,0,139,0,0,0,0,0,0,0, +147,0,0,0,0,0,0,140,0,165,0,166,0,0,0,0, +0,0,0,0,0,0,141,142,0,0,167,168,169,143,144,71, +0,73,0,0,145,0,0,0,0,469,146,138,0,153,0,0, +0,154,155,156,0,157,0,158,0,0,0,0,159,0,0,160, +0,0,0,161,0,0,0,0,162,0,163,164,0,0,0,139, +148,149,0,0,150,0,151,147,0,0,0,0,0,0,140,0, +165,0,166,0,0,0,0,0,0,0,0,0,0,141,142,0, +0,167,168,169,143,144,71,0,73,0,0,145,0,0,0,0, +474,146,138,0,153,0,0,0,154,155,156,0,157,0,158,0, +0,0,0,159,0,0,160,0,0,0,161,0,0,0,0,162, +0,163,164,0,0,0,139,148,149,0,0,150,0,151,147,0, +0,0,0,0,0,140,0,165,0,166,0,0,0,0,0,0, +0,0,0,0,141,142,0,0,167,168,169,143,144,71,0,73, +0,0,145,0,0,0,0,0,146,138,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,147,0,65,0,438,0,0,132,135,0,0,0,136,137, -138,0,139,148,140,0,66,0,67,141,0,0,142,0,133,0, -143,29,123,30,0,144,0,145,146,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,0,0,0,147,0,65, -0,0,0,0,0,0,124,0,0,0,0,0,0,0,148,0, -0,66,0,67,0,125,0,0,0,133,0,0,29,123,30,0, -0,0,0,0,126,127,0,0,0,0,0,128,129,0,0,0, -0,0,130,0,0,0,0,0,131,0,0,0,0,0,0,0, -0,124,0,0,0,0,0,0,0,0,0,0,0,0,0,442, -125,0,132,135,0,0,0,136,137,138,0,139,0,140,0,126, -127,0,141,0,0,142,128,129,0,143,0,0,0,130,144,0, -145,146,0,131,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,147,0,65,0,0,0,0,132,0,0, -0,0,0,0,0,0,0,148,0,0,66,0,67,0,0,0, -0,0,133,0,0,29,123,30,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,139,148,149, +0,0,150,0,151,147,0,0,0,0,0,0,140,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,141,142,0,0,0, +0,0,143,144,0,0,0,0,0,145,0,0,0,0,0,146, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,0,124,0,0,0,0,0, -0,0,0,0,0,0,0,0,0,125,0,0,0,133,0,0, -29,0,30,0,0,0,0,0,126,127,0,0,0,0,0,128, -129,0,0,0,0,0,130,0,0,0,0,0,131,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,132,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,148,149,0,0,150,0,151,147,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, -0,0,0,0,0,0,133,0,0,29,0,30}; +0,0,0,0,0,0,0,0,0,0,0,0,148,149,0,0, +150,0,151}; D_ErrorRecoveryHint d_error_recovery_hints_0_rxode2parse[] = { {0, 5, "}"}, @@ -6448,95 +6828,105 @@ D_ErrorRecoveryHint d_error_recovery_hints_6_rxode2parse[] = {{1, 12, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_7_rxode2parse[] = {{1, 13, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_8_rxode2parse[] = {{1, 14, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_16_rxode2parse[] = {{1, 29, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_42_rxode2parse[] = {{1, 19, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_44_rxode2parse[] = {{1, 25, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_70_rxode2parse[] = {{2, 5, "}"}}; -D_ErrorRecoveryHint d_error_recovery_hints_71_rxode2parse[] = {{0, 76, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_73_rxode2parse[] = {{2, 12, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_74_rxode2parse[] = {{2, 13, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_75_rxode2parse[] = { -{0, 126, "]"}, +D_ErrorRecoveryHint d_error_recovery_hints_25_rxode2parse[] = {{1, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_43_rxode2parse[] = {{1, 19, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_45_rxode2parse[] = {{1, 25, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_77_rxode2parse[] = {{2, 5, "}"}}; +D_ErrorRecoveryHint d_error_recovery_hints_78_rxode2parse[] = {{0, 84, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_80_rxode2parse[] = {{2, 12, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_81_rxode2parse[] = {{2, 13, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_82_rxode2parse[] = { +{0, 134, "]"}, {2, 14, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_76_rxode2parse[] = {{2, 29, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_90_rxode2parse[] = { -{0, 126, "]"}, +D_ErrorRecoveryHint d_error_recovery_hints_83_rxode2parse[] = {{2, 29, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_88_rxode2parse[] = {{2, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_98_rxode2parse[] = { +{0, 134, "]"}, {2, 19, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_92_rxode2parse[] = {{2, 25, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_121_rxode2parse[] = {{3, 5, "}"}}; -D_ErrorRecoveryHint d_error_recovery_hints_122_rxode2parse[] = {{1, 76, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_144_rxode2parse[] = { +D_ErrorRecoveryHint d_error_recovery_hints_100_rxode2parse[] = {{2, 25, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_136_rxode2parse[] = {{3, 5, "}"}}; +D_ErrorRecoveryHint d_error_recovery_hints_137_rxode2parse[] = {{1, 84, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_162_rxode2parse[] = { {0, 43, ")"}, -{0, 126, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_149_rxode2parse[] = {{3, 12, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_152_rxode2parse[] = {{3, 13, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_160_rxode2parse[] = {{3, 14, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_163_rxode2parse[] = {{1, 126, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_165_rxode2parse[] = {{1, 128, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_169_rxode2parse[] = {{3, 29, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_178_rxode2parse[] = {{3, 19, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_183_rxode2parse[] = {{3, 25, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_195_rxode2parse[] = {{2, 76, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_202_rxode2parse[] = {{1, 112, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_212_rxode2parse[] = {{1, 111, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_214_rxode2parse[] = {{1, 43, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_215_rxode2parse[] = {{1, 47, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_241_rxode2parse[] = {{4, 13, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_242_rxode2parse[] = {{4, 14, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_243_rxode2parse[] = {{2, 126, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_244_rxode2parse[] = {{2, 128, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_245_rxode2parse[] = {{4, 29, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_248_rxode2parse[] = {{0, 132, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_252_rxode2parse[] = {{4, 19, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_253_rxode2parse[] = {{4, 25, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_259_rxode2parse[] = {{3, 76, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_264_rxode2parse[] = {{2, 112, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_296_rxode2parse[] = {{2, 110, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_297_rxode2parse[] = {{2, 43, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_298_rxode2parse[] = {{2, 47, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_306_rxode2parse[] = {{0, 126, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_307_rxode2parse[] = {{5, 14, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_310_rxode2parse[] = {{3, 126, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_311_rxode2parse[] = {{3, 128, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_313_rxode2parse[] = {{5, 29, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_326_rxode2parse[] = {{1, 132, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_328_rxode2parse[] = {{1, 134, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_344_rxode2parse[] = {{5, 19, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_347_rxode2parse[] = {{5, 25, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_357_rxode2parse[] = {{4, 76, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_368_rxode2parse[] = {{3, 111, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_369_rxode2parse[] = {{3, 110, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_370_rxode2parse[] = {{3, 43, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_371_rxode2parse[] = {{3, 47, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_385_rxode2parse[] = {{4, 126, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_386_rxode2parse[] = {{4, 128, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_392_rxode2parse[] = {{2, 132, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_393_rxode2parse[] = {{2, 134, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_406_rxode2parse[] = {{4, 112, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_410_rxode2parse[] = {{4, 43, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_411_rxode2parse[] = { -{0, 132, "]"}, +{0, 134, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_170_rxode2parse[] = {{3, 12, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_173_rxode2parse[] = {{3, 13, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_179_rxode2parse[] = {{3, 14, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_182_rxode2parse[] = {{1, 134, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_184_rxode2parse[] = {{1, 136, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_188_rxode2parse[] = {{3, 29, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_194_rxode2parse[] = {{3, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_198_rxode2parse[] = {{3, 19, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_203_rxode2parse[] = {{3, 25, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_216_rxode2parse[] = {{2, 84, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_223_rxode2parse[] = {{1, 120, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_233_rxode2parse[] = {{1, 119, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_235_rxode2parse[] = {{1, 43, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_236_rxode2parse[] = {{1, 47, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_262_rxode2parse[] = {{4, 13, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_263_rxode2parse[] = {{4, 14, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_264_rxode2parse[] = {{2, 134, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_265_rxode2parse[] = {{2, 136, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_266_rxode2parse[] = {{4, 29, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_269_rxode2parse[] = {{0, 140, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_272_rxode2parse[] = {{4, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_274_rxode2parse[] = {{4, 19, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_275_rxode2parse[] = {{4, 25, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_281_rxode2parse[] = {{3, 84, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_286_rxode2parse[] = {{2, 120, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_318_rxode2parse[] = {{2, 118, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_319_rxode2parse[] = {{2, 43, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_320_rxode2parse[] = {{2, 47, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_328_rxode2parse[] = {{0, 134, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_329_rxode2parse[] = {{5, 14, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_332_rxode2parse[] = {{3, 134, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_333_rxode2parse[] = {{3, 136, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_335_rxode2parse[] = {{5, 29, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_348_rxode2parse[] = {{1, 140, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_350_rxode2parse[] = {{1, 142, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_364_rxode2parse[] = {{5, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_371_rxode2parse[] = {{5, 19, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_374_rxode2parse[] = {{5, 25, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_384_rxode2parse[] = {{4, 84, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_395_rxode2parse[] = {{3, 119, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_396_rxode2parse[] = {{3, 118, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_397_rxode2parse[] = {{3, 43, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_398_rxode2parse[] = {{3, 47, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_412_rxode2parse[] = {{4, 134, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_413_rxode2parse[] = {{4, 136, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_419_rxode2parse[] = {{2, 140, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_420_rxode2parse[] = {{2, 142, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_423_rxode2parse[] = {{6, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_435_rxode2parse[] = {{4, 120, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_439_rxode2parse[] = {{4, 43, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_440_rxode2parse[] = { +{0, 140, "]"}, {4, 47, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_422_rxode2parse[] = {{3, 132, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_423_rxode2parse[] = {{3, 134, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_425_rxode2parse[] = {{5, 112, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_428_rxode2parse[] = {{5, 111, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_429_rxode2parse[] = {{5, 47, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_435_rxode2parse[] = {{4, 132, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_436_rxode2parse[] = {{4, 134, "]"}}; -D_ErrorRecoveryHint d_error_recovery_hints_440_rxode2parse[] = {{6, 47, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_441_rxode2parse[] = {{7, 111, ")"}}; -D_ErrorRecoveryHint d_error_recovery_hints_442_rxode2parse[] = {{8, 111, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_451_rxode2parse[] = {{3, 140, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_452_rxode2parse[] = {{3, 142, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_453_rxode2parse[] = {{7, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_455_rxode2parse[] = {{5, 120, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_458_rxode2parse[] = {{5, 119, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_459_rxode2parse[] = {{5, 47, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_465_rxode2parse[] = {{4, 140, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_466_rxode2parse[] = {{4, 142, "]"}}; +D_ErrorRecoveryHint d_error_recovery_hints_467_rxode2parse[] = {{8, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_471_rxode2parse[] = {{6, 47, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_472_rxode2parse[] = {{9, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_473_rxode2parse[] = {{7, 119, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_475_rxode2parse[] = {{10, 66, ")"}}; +D_ErrorRecoveryHint d_error_recovery_hints_477_rxode2parse[] = {{8, 119, ")"}}; D_State d_states_rxode2parse[] = { {d_goto_valid_0_rxode2parse, 1, {1, d_reductions_0_rxode2parse}, {2, d_right_epsilon_hints_0_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, -{d_goto_valid_1_rxode2parse, 140, {1, d_reductions_1_rxode2parse}, {1, d_right_epsilon_hints_1_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_2_rxode2parse, -254, {2, d_reductions_2_rxode2parse}, {2, d_right_epsilon_hints_2_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, -{d_goto_valid_3_rxode2parse, 150, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_4_rxode2parse, 141, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_1_rxode2parse, 150, {1, d_reductions_1_rxode2parse}, {1, d_right_epsilon_hints_1_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_2_rxode2parse, -263, {2, d_reductions_2_rxode2parse}, {2, d_right_epsilon_hints_2_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, +{d_goto_valid_3_rxode2parse, 160, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_4_rxode2parse, 151, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_5_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_6_rxode2parse, 140, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_6_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_7_rxode2parse, 139, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_7_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_8_rxode2parse, 138, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_8_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_6_rxode2parse, 150, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_6_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_7_rxode2parse, 149, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_7_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_8_rxode2parse, 148, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_8_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_9_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_10_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_11_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, @@ -6544,433 +6934,469 @@ D_State d_states_rxode2parse[] = { {NULL, -2147483647, {1, d_reductions_13_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_14_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_15_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_16_rxode2parse, 136, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_16_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_17_rxode2parse, 135, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_18_rxode2parse, 134, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_16_rxode2parse, 146, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_16_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_17_rxode2parse, 145, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_18_rxode2parse, 144, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, {NULL, -2147483647, {2, d_reductions_19_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {2, d_reductions_20_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {2, d_reductions_21_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {2, d_reductions_22_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_23_rxode2parse, 133, {1, d_reductions_23_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_24_rxode2parse, 130, {1, d_reductions_24_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_25_rxode2parse, 167, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_25_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_25_rxode2parse, d_accepts_diff_25_rxode2parse, -1}, -{d_goto_valid_26_rxode2parse, 164, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_25_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_25_rxode2parse, d_accepts_diff_25_rxode2parse, -1}, -{d_goto_valid_27_rxode2parse, 125, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_28_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_29_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_23_rxode2parse, 143, {1, d_reductions_23_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_24_rxode2parse, 140, {1, d_reductions_24_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_25_rxode2parse, 139, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_25_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_26_rxode2parse, 174, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_26_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_26_rxode2parse, d_accepts_diff_26_rxode2parse, -1}, +{d_goto_valid_27_rxode2parse, 173, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_26_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_26_rxode2parse, d_accepts_diff_26_rxode2parse, -1}, +{d_goto_valid_28_rxode2parse, 134, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{NULL, -2147483647, {2, d_reductions_29_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_30_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {0, NULL}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 1, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_31_rxode2parse, -489, {2, d_reductions_31_rxode2parse}, {2, d_right_epsilon_hints_31_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_32_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_32_rxode2parse, -525, {2, d_reductions_32_rxode2parse}, {2, d_right_epsilon_hints_32_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_33_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_34_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_35_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_36_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_37_rxode2parse, 28, {1, d_reductions_37_rxode2parse}, {2, d_right_epsilon_hints_37_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_37_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_38_rxode2parse, 19, {1, d_reductions_38_rxode2parse}, {2, d_right_epsilon_hints_38_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_39_rxode2parse, 15, {1, d_reductions_39_rxode2parse}, {2, d_right_epsilon_hints_39_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_40_rxode2parse, 13, {1, d_reductions_40_rxode2parse}, {2, d_right_epsilon_hints_40_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_41_rxode2parse, -7, {1, d_reductions_41_rxode2parse}, {2, d_right_epsilon_hints_41_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_42_rxode2parse, 121, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_42_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_43_rxode2parse, -9, {1, d_reductions_43_rxode2parse}, {2, d_right_epsilon_hints_43_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_44_rxode2parse, 119, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_44_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_45_rxode2parse, -11, {1, d_reductions_45_rxode2parse}, {2, d_right_epsilon_hints_45_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_46_rxode2parse, -13, {1, d_reductions_46_rxode2parse}, {2, d_right_epsilon_hints_46_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_47_rxode2parse, -15, {1, d_reductions_47_rxode2parse}, {2, d_right_epsilon_hints_47_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_48_rxode2parse, -17, {1, d_reductions_48_rxode2parse}, {2, d_right_epsilon_hints_48_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_49_rxode2parse, -19, {1, d_reductions_49_rxode2parse}, {2, d_right_epsilon_hints_49_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_50_rxode2parse, -21, {1, d_reductions_50_rxode2parse}, {2, d_right_epsilon_hints_50_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_51_rxode2parse, -23, {1, d_reductions_51_rxode2parse}, {2, d_right_epsilon_hints_51_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_52_rxode2parse, 117, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_53_rxode2parse, -25, {1, d_reductions_53_rxode2parse}, {2, d_right_epsilon_hints_53_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_54_rxode2parse, 113, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_55_rxode2parse, -27, {1, d_reductions_55_rxode2parse}, {2, d_right_epsilon_hints_55_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_56_rxode2parse, -29, {1, d_reductions_56_rxode2parse}, {2, d_right_epsilon_hints_56_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_57_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_58_rxode2parse, 12, {1, d_reductions_58_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_58_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_58_rxode2parse, d_accepts_diff_58_rxode2parse, -1}, -{d_goto_valid_59_rxode2parse, -31, {1, d_reductions_59_rxode2parse}, {2, d_right_epsilon_hints_59_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_60_rxode2parse, -33, {1, d_reductions_60_rxode2parse}, {2, d_right_epsilon_hints_60_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_61_rxode2parse, -35, {1, d_reductions_61_rxode2parse}, {2, d_right_epsilon_hints_61_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_62_rxode2parse, -37, {1, d_reductions_62_rxode2parse}, {2, d_right_epsilon_hints_62_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_63_rxode2parse, -82, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_63_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_63_rxode2parse, d_accepts_diff_63_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_64_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_65_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_66_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_42_rxode2parse, -15, {1, d_reductions_42_rxode2parse}, {2, d_right_epsilon_hints_42_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_43_rxode2parse, 133, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_43_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_44_rxode2parse, -17, {1, d_reductions_44_rxode2parse}, {2, d_right_epsilon_hints_44_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_45_rxode2parse, 131, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_45_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_46_rxode2parse, -19, {1, d_reductions_46_rxode2parse}, {2, d_right_epsilon_hints_46_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_47_rxode2parse, -21, {1, d_reductions_47_rxode2parse}, {2, d_right_epsilon_hints_47_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_48_rxode2parse, -23, {1, d_reductions_48_rxode2parse}, {2, d_right_epsilon_hints_48_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_49_rxode2parse, -25, {1, d_reductions_49_rxode2parse}, {2, d_right_epsilon_hints_49_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_50_rxode2parse, -27, {1, d_reductions_50_rxode2parse}, {2, d_right_epsilon_hints_50_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_51_rxode2parse, -29, {1, d_reductions_51_rxode2parse}, {2, d_right_epsilon_hints_51_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_52_rxode2parse, -31, {1, d_reductions_52_rxode2parse}, {2, d_right_epsilon_hints_52_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_53_rxode2parse, 129, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_54_rxode2parse, -33, {1, d_reductions_54_rxode2parse}, {2, d_right_epsilon_hints_54_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_55_rxode2parse, 127, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_56_rxode2parse, -35, {1, d_reductions_56_rxode2parse}, {2, d_right_epsilon_hints_56_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_57_rxode2parse, -37, {1, d_reductions_57_rxode2parse}, {2, d_right_epsilon_hints_57_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_58_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_59_rxode2parse, 12, {1, d_reductions_59_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_59_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_59_rxode2parse, d_accepts_diff_59_rxode2parse, -1}, +{d_goto_valid_60_rxode2parse, -39, {1, d_reductions_60_rxode2parse}, {2, d_right_epsilon_hints_60_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_61_rxode2parse, -41, {1, d_reductions_61_rxode2parse}, {2, d_right_epsilon_hints_61_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_62_rxode2parse, -43, {1, d_reductions_62_rxode2parse}, {2, d_right_epsilon_hints_62_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_63_rxode2parse, -45, {1, d_reductions_63_rxode2parse}, {2, d_right_epsilon_hints_63_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_64_rxode2parse, -47, {1, d_reductions_64_rxode2parse}, {2, d_right_epsilon_hints_64_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_65_rxode2parse, -49, {1, d_reductions_65_rxode2parse}, {2, d_right_epsilon_hints_65_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_66_rxode2parse, -51, {1, d_reductions_66_rxode2parse}, {2, d_right_epsilon_hints_66_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_67_rxode2parse, -106, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_67_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_67_rxode2parse, d_accepts_diff_67_rxode2parse, -1}, +{d_goto_valid_68_rxode2parse, 23, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, +{NULL, -2147483647, {2, d_reductions_69_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_70_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_71_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_72_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_73_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {0, NULL}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 1, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_68_rxode2parse, 34, {1, d_reductions_68_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_69_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_70_rxode2parse, 101, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_70_rxode2parse}, 1, NULL, (void*)d_scanner_70_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_70_rxode2parse, d_accepts_diff_70_rxode2parse, -1}, -{d_goto_valid_71_rxode2parse, -506, {1, d_reductions_71_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_72_rxode2parse, -614, {1, d_reductions_72_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_73_rxode2parse, 103, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_73_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_74_rxode2parse, 26, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_74_rxode2parse}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_75_rxode2parse, -245, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_75_rxode2parse}, 1, NULL, (void*)d_scanner_75_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_75_rxode2parse, d_accepts_diff_75_rxode2parse, -1}, -{d_goto_valid_76_rxode2parse, -73, {1, d_reductions_76_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_76_rxode2parse}, 1, NULL, (void*)d_scanner_76_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_76_rxode2parse, d_accepts_diff_76_rxode2parse, -1}, -{d_goto_valid_77_rxode2parse, 17, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_78_rxode2parse, -8, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_79_rxode2parse, -223, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_80_rxode2parse, -559, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_81_rxode2parse, -789, {1, d_reductions_81_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_82_rxode2parse, -848, {1, d_reductions_82_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_83_rxode2parse, -563, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_84_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_85_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_86_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_87_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_88_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_89_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_90_rxode2parse, -871, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_90_rxode2parse}, 1, NULL, (void*)d_scanner_75_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_75_rxode2parse, d_accepts_diff_75_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_91_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_92_rxode2parse, 78, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_92_rxode2parse}, 1, NULL, (void*)d_scanner_92_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_92_rxode2parse, d_accepts_diff_92_rxode2parse, -1}, +{d_goto_valid_75_rxode2parse, 47, {1, d_reductions_75_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_75_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_75_rxode2parse, d_accepts_diff_75_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_76_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_77_rxode2parse, 111, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_77_rxode2parse}, 1, NULL, (void*)d_scanner_77_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_77_rxode2parse, d_accepts_diff_77_rxode2parse, -1}, +{d_goto_valid_78_rxode2parse, -542, {1, d_reductions_78_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_79_rxode2parse, -716, {1, d_reductions_79_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_80_rxode2parse, 113, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_80_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_81_rxode2parse, 17, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_81_rxode2parse}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_82_rxode2parse, -254, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_82_rxode2parse}, 1, NULL, (void*)d_scanner_82_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_82_rxode2parse, d_accepts_diff_82_rxode2parse, -1}, +{d_goto_valid_83_rxode2parse, -85, {1, d_reductions_83_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_83_rxode2parse}, 1, NULL, (void*)d_scanner_83_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_83_rxode2parse, d_accepts_diff_83_rxode2parse, -1}, +{d_goto_valid_84_rxode2parse, -509, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_85_rxode2parse, -597, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_86_rxode2parse, -612, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_87_rxode2parse, -629, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_88_rxode2parse, -665, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_88_rxode2parse}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_89_rxode2parse, -886, {1, d_reductions_89_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_90_rxode2parse, -973, {1, d_reductions_90_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_91_rxode2parse, -699, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_92_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_93_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_94_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_95_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_96_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_97_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_98_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_98_rxode2parse, -977, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_98_rxode2parse}, 1, NULL, (void*)d_scanner_82_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_82_rxode2parse, d_accepts_diff_82_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_99_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_100_rxode2parse, -812, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, +{d_goto_valid_100_rxode2parse, 29, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_100_rxode2parse}, 1, NULL, (void*)d_scanner_100_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_100_rxode2parse, d_accepts_diff_100_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_101_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_102_rxode2parse, -816, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_102_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_103_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_104_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_105_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_106_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_107_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_108_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_108_rxode2parse, -910, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_109_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_110_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_111_rxode2parse, -77, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_111_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_111_rxode2parse, d_accepts_diff_111_rxode2parse, -1}, -{NULL, -2147483647, {2, d_reductions_112_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_113_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_110_rxode2parse, -941, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_111_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_112_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_113_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_114_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_115_rxode2parse, 9, {1, d_reductions_115_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_76_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_76_rxode2parse, d_accepts_diff_76_rxode2parse, -1}, -{d_goto_valid_116_rxode2parse, -1135, {1, d_reductions_116_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_115_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_116_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_117_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_118_rxode2parse, 300, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_118_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_118_rxode2parse, d_accepts_diff_118_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_118_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_119_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_120_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_121_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_121_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_122_rxode2parse, -1027, {1, d_reductions_122_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_122_rxode2parse}, 1, NULL, (void*)d_scanner_122_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_122_rxode2parse, d_accepts_diff_122_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_123_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_124_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_121_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_122_rxode2parse, -90, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_122_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_122_rxode2parse, d_accepts_diff_122_rxode2parse, -1}, +{NULL, -2147483647, {2, d_reductions_123_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_124_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_125_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_126_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_127_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_126_rxode2parse, 4, {1, d_reductions_126_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_83_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_83_rxode2parse, d_accepts_diff_83_rxode2parse, -1}, +{d_goto_valid_127_rxode2parse, -1145, {1, d_reductions_127_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_128_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_129_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_130_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_131_rxode2parse, -1010, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_131_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_131_rxode2parse, d_accepts_diff_131_rxode2parse, -1}, +{d_goto_valid_131_rxode2parse, 15, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_100_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_100_rxode2parse, d_accepts_diff_100_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_132_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_133_rxode2parse, 96, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_133_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_133_rxode2parse, d_accepts_diff_133_rxode2parse, -1}, -{d_goto_valid_134_rxode2parse, -31, {1, d_reductions_134_rxode2parse}, {1, d_right_epsilon_hints_134_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_135_rxode2parse, -28, {1, d_reductions_135_rxode2parse}, {1, d_right_epsilon_hints_135_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_136_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_137_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_133_rxode2parse, 330, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_133_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_133_rxode2parse, d_accepts_diff_133_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_134_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_135_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_136_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_136_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_137_rxode2parse, -1303, {1, d_reductions_137_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_137_rxode2parse}, 1, NULL, (void*)d_scanner_137_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_137_rxode2parse, d_accepts_diff_137_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_138_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_139_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_140_rxode2parse, -19, {1, d_reductions_140_rxode2parse}, {1, d_right_epsilon_hints_140_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_141_rxode2parse, -15, {1, d_reductions_141_rxode2parse}, {1, d_right_epsilon_hints_141_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_142_rxode2parse, -13, {1, d_reductions_142_rxode2parse}, {1, d_right_epsilon_hints_142_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_143_rxode2parse, -16, {1, d_reductions_143_rxode2parse}, {1, d_right_epsilon_hints_143_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_144_rxode2parse, -1278, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_144_rxode2parse}, 1, NULL, (void*)d_scanner_144_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_144_rxode2parse, d_accepts_diff_144_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_140_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_141_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_142_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_143_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_144_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_145_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_146_rxode2parse, -47, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_146_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_146_rxode2parse, d_accepts_diff_146_rxode2parse, -1}, -{d_goto_valid_147_rxode2parse, -51, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_146_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_146_rxode2parse, d_accepts_diff_146_rxode2parse, -1}, -{d_goto_valid_148_rxode2parse, 45, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_149_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_149_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_146_rxode2parse, -1186, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_146_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_146_rxode2parse, d_accepts_diff_146_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_147_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_148_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_149_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_150_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_151_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_152_rxode2parse, 43, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_152_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_153_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_151_rxode2parse, 106, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_151_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_151_rxode2parse, d_accepts_diff_151_rxode2parse, -1}, +{d_goto_valid_152_rxode2parse, 15, {1, d_reductions_152_rxode2parse}, {1, d_right_epsilon_hints_152_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_153_rxode2parse, 17, {1, d_reductions_153_rxode2parse}, {1, d_right_epsilon_hints_153_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_154_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_155_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_156_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_157_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_158_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_159_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_160_rxode2parse, -104, {1, d_reductions_160_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_160_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_161_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_162_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_163_rxode2parse, 200, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_163_rxode2parse}, 1, NULL, (void*)d_scanner_163_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_163_rxode2parse, d_accepts_diff_163_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_164_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_165_rxode2parse, 198, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_165_rxode2parse}, 1, NULL, (void*)d_scanner_163_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_163_rxode2parse, d_accepts_diff_163_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_166_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_156_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_157_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_158_rxode2parse, 23, {1, d_reductions_158_rxode2parse}, {1, d_right_epsilon_hints_158_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_159_rxode2parse, 26, {1, d_reductions_159_rxode2parse}, {1, d_right_epsilon_hints_159_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_160_rxode2parse, -13, {1, d_reductions_160_rxode2parse}, {1, d_right_epsilon_hints_160_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_161_rxode2parse, -21, {1, d_reductions_161_rxode2parse}, {1, d_right_epsilon_hints_161_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_162_rxode2parse, -1359, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_162_rxode2parse}, 1, NULL, (void*)d_scanner_162_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_162_rxode2parse, d_accepts_diff_162_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_163_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_164_rxode2parse, -40, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_164_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_164_rxode2parse, d_accepts_diff_164_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_165_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_166_rxode2parse, -49, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_164_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_164_rxode2parse, d_accepts_diff_164_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_167_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_168_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_169_rxode2parse, -96, {1, d_reductions_169_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_169_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_170_rxode2parse, 8, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_170_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_170_rxode2parse, d_accepts_diff_170_rxode2parse, -1}, -{d_goto_valid_171_rxode2parse, 24, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_172_rxode2parse, 78, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_172_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_172_rxode2parse, d_accepts_diff_172_rxode2parse, -1}, -{d_goto_valid_173_rxode2parse, 22, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_174_rxode2parse, 21, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_175_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_176_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_177_rxode2parse, 20, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_178_rxode2parse, -119, {1, d_reductions_178_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_178_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_179_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_169_rxode2parse, 42, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_170_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_170_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_171_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_172_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_173_rxode2parse, 40, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_173_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_174_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_175_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_176_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_177_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_178_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_179_rxode2parse, -123, {1, d_reductions_179_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_179_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_180_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_181_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_182_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_183_rxode2parse, -114, {1, d_reductions_183_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_183_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_184_rxode2parse, 17, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_185_rxode2parse, 15, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{NULL, -2147483647, {2, d_reductions_186_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_187_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_188_rxode2parse, -28, {1, d_reductions_188_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_76_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_76_rxode2parse, d_accepts_diff_76_rxode2parse, -1}, -{d_goto_valid_189_rxode2parse, -1440, {1, d_reductions_189_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_190_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_191_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_192_rxode2parse, -38, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_192_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_192_rxode2parse, d_accepts_diff_192_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_193_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_194_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_195_rxode2parse, -381, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_195_rxode2parse}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_196_rxode2parse, 10, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_195_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_197_rxode2parse, 9, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_195_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_198_rxode2parse, -1206, {1, d_reductions_198_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_195_rxode2parse}, 1, NULL, (void*)d_scanner_198_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_198_rxode2parse, d_accepts_diff_198_rxode2parse, -1}, -{NULL, -2147483647, {2, d_reductions_199_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_200_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_182_rxode2parse, 212, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_182_rxode2parse}, 1, NULL, (void*)d_scanner_182_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_182_rxode2parse, d_accepts_diff_182_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_183_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_184_rxode2parse, 211, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_184_rxode2parse}, 1, NULL, (void*)d_scanner_182_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_182_rxode2parse, d_accepts_diff_182_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_185_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_186_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_187_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_188_rxode2parse, -112, {1, d_reductions_188_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_188_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_189_rxode2parse, 4, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_189_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_189_rxode2parse, d_accepts_diff_189_rxode2parse, -1}, +{d_goto_valid_190_rxode2parse, 24, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_191_rxode2parse, 77, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_191_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_191_rxode2parse, d_accepts_diff_191_rxode2parse, -1}, +{d_goto_valid_192_rxode2parse, 21, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_193_rxode2parse, 20, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_194_rxode2parse, 19, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_194_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_195_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_196_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_197_rxode2parse, 18, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_198_rxode2parse, -131, {1, d_reductions_198_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_198_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_199_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_200_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_201_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_202_rxode2parse, 5, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_202_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_203_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_204_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_205_rxode2parse, -1659, {1, d_reductions_205_rxode2parse}, {2, d_right_epsilon_hints_205_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, -{d_goto_valid_206_rxode2parse, -94, {1, d_reductions_206_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_206_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_206_rxode2parse, d_accepts_diff_206_rxode2parse, -1}, -{d_goto_valid_207_rxode2parse, -81, {1, d_reductions_207_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_207_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_207_rxode2parse, d_accepts_diff_207_rxode2parse, -1}, -{d_goto_valid_208_rxode2parse, -83, {1, d_reductions_208_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_146_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_146_rxode2parse, d_accepts_diff_146_rxode2parse, -1}, -{d_goto_valid_209_rxode2parse, -105, {1, d_reductions_209_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_209_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_209_rxode2parse, d_accepts_diff_209_rxode2parse, -1}, -{d_goto_valid_210_rxode2parse, -95, {1, d_reductions_210_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_210_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_210_rxode2parse, d_accepts_diff_210_rxode2parse, -1}, -{d_goto_valid_211_rxode2parse, -110, {1, d_reductions_211_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_211_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_211_rxode2parse, d_accepts_diff_211_rxode2parse, -1}, -{d_goto_valid_212_rxode2parse, -2, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_212_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_213_rxode2parse, -1676, {1, d_reductions_213_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_214_rxode2parse, -4, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_214_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{d_goto_valid_215_rxode2parse, -6, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_215_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_216_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_217_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_218_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_219_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_220_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_221_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_202_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_203_rxode2parse, -130, {1, d_reductions_203_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_203_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_204_rxode2parse, 11, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_205_rxode2parse, 10, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{NULL, -2147483647, {2, d_reductions_206_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_207_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_208_rxode2parse, -38, {1, d_reductions_208_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_83_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_83_rxode2parse, d_accepts_diff_83_rxode2parse, -1}, +{d_goto_valid_209_rxode2parse, -1539, {1, d_reductions_209_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_210_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_211_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_212_rxode2parse, -60, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_212_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_212_rxode2parse, d_accepts_diff_212_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_213_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_214_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_215_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_216_rxode2parse, -1313, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_216_rxode2parse}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_217_rxode2parse, 9, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_216_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_218_rxode2parse, 8, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_216_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_219_rxode2parse, -1567, {1, d_reductions_219_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_216_rxode2parse}, 1, NULL, (void*)d_scanner_219_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_219_rxode2parse, d_accepts_diff_219_rxode2parse, -1}, +{NULL, -2147483647, {2, d_reductions_220_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_221_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_222_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_223_rxode2parse, -81, {1, d_reductions_223_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_223_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_223_rxode2parse, d_accepts_diff_223_rxode2parse, -1}, +{d_goto_valid_223_rxode2parse, 3, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_223_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_224_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_225_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_226_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_227_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_228_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_229_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_230_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_231_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_232_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_233_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_234_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_235_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_236_rxode2parse, -31, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_92_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_92_rxode2parse, d_accepts_diff_92_rxode2parse, -1}, +{d_goto_valid_226_rxode2parse, -1803, {1, d_reductions_226_rxode2parse}, {2, d_right_epsilon_hints_226_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, +{d_goto_valid_227_rxode2parse, -92, {1, d_reductions_227_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_227_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_227_rxode2parse, d_accepts_diff_227_rxode2parse, -1}, +{d_goto_valid_228_rxode2parse, -84, {1, d_reductions_228_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_228_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_228_rxode2parse, d_accepts_diff_228_rxode2parse, -1}, +{d_goto_valid_229_rxode2parse, -95, {1, d_reductions_229_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_164_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_164_rxode2parse, d_accepts_diff_164_rxode2parse, -1}, +{d_goto_valid_230_rxode2parse, -149, {1, d_reductions_230_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_230_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_230_rxode2parse, d_accepts_diff_230_rxode2parse, -1}, +{d_goto_valid_231_rxode2parse, -103, {1, d_reductions_231_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_231_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_231_rxode2parse, d_accepts_diff_231_rxode2parse, -1}, +{d_goto_valid_232_rxode2parse, -121, {1, d_reductions_232_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_232_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_232_rxode2parse, d_accepts_diff_232_rxode2parse, -1}, +{d_goto_valid_233_rxode2parse, -9, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_233_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_234_rxode2parse, -1942, {1, d_reductions_234_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_235_rxode2parse, -10, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_235_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{d_goto_valid_236_rxode2parse, -12, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_236_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_237_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_238_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_239_rxode2parse, -1209, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_240_rxode2parse, -1911, {1, d_reductions_240_rxode2parse}, {2, d_right_epsilon_hints_240_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_241_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_241_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_242_rxode2parse, -154, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_242_rxode2parse}, 1, NULL, (void*)d_scanner_242_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_242_rxode2parse, d_accepts_diff_242_rxode2parse, -1}, -{d_goto_valid_243_rxode2parse, -40, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_243_rxode2parse}, 1, NULL, (void*)d_scanner_243_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_243_rxode2parse, d_accepts_diff_243_rxode2parse, -1}, -{d_goto_valid_244_rxode2parse, -55, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_244_rxode2parse}, 1, NULL, (void*)d_scanner_243_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_243_rxode2parse, d_accepts_diff_243_rxode2parse, -1}, -{d_goto_valid_245_rxode2parse, -167, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_245_rxode2parse}, 1, NULL, (void*)d_scanner_242_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_242_rxode2parse, d_accepts_diff_242_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_239_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_240_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_241_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_242_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_243_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_244_rxode2parse, -82, {1, d_reductions_244_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_244_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_244_rxode2parse, d_accepts_diff_244_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_245_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_246_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_247_rxode2parse, -209, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_247_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_247_rxode2parse, d_accepts_diff_247_rxode2parse, -1}, -{d_goto_valid_248_rxode2parse, -1906, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_248_rxode2parse}, 1, NULL, (void*)d_scanner_75_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_75_rxode2parse, d_accepts_diff_75_rxode2parse, -1}, -{d_goto_valid_249_rxode2parse, -136, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_247_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_247_rxode2parse, d_accepts_diff_247_rxode2parse, -1}, -{d_goto_valid_250_rxode2parse, -222, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_247_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_247_rxode2parse, d_accepts_diff_247_rxode2parse, -1}, -{d_goto_valid_251_rxode2parse, -149, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_247_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_247_rxode2parse, d_accepts_diff_247_rxode2parse, -1}, -{d_goto_valid_252_rxode2parse, -201, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_252_rxode2parse}, 1, NULL, (void*)d_scanner_242_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_242_rxode2parse, d_accepts_diff_242_rxode2parse, -1}, -{d_goto_valid_253_rxode2parse, -254, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_253_rxode2parse}, 1, NULL, (void*)d_scanner_242_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_242_rxode2parse, d_accepts_diff_242_rxode2parse, -1}, -{d_goto_valid_254_rxode2parse, -241, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_247_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_247_rxode2parse, d_accepts_diff_247_rxode2parse, -1}, -{d_goto_valid_255_rxode2parse, -232, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_247_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_247_rxode2parse, d_accepts_diff_247_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_247_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_248_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_249_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_250_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_251_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_252_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_253_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_254_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_255_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_256_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_257_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_257_rxode2parse, -52, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_100_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_100_rxode2parse, d_accepts_diff_100_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_258_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_259_rxode2parse, -14, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_259_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_260_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_259_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_261_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_259_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_262_rxode2parse, -23, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_259_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_263_rxode2parse, -39, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_259_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_264_rxode2parse, -85, {1, d_reductions_264_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_264_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_265_rxode2parse, -45, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_133_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_133_rxode2parse, d_accepts_diff_133_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_266_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_259_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_260_rxode2parse, -1350, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_261_rxode2parse, -2195, {1, d_reductions_261_rxode2parse}, {2, d_right_epsilon_hints_261_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_262_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_262_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_263_rxode2parse, -162, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_263_rxode2parse}, 1, NULL, (void*)d_scanner_263_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_263_rxode2parse, d_accepts_diff_263_rxode2parse, -1}, +{d_goto_valid_264_rxode2parse, -36, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_264_rxode2parse}, 1, NULL, (void*)d_scanner_264_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_264_rxode2parse, d_accepts_diff_264_rxode2parse, -1}, +{d_goto_valid_265_rxode2parse, -59, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_265_rxode2parse}, 1, NULL, (void*)d_scanner_264_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_264_rxode2parse, d_accepts_diff_264_rxode2parse, -1}, +{d_goto_valid_266_rxode2parse, -158, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_266_rxode2parse}, 1, NULL, (void*)d_scanner_263_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_263_rxode2parse, d_accepts_diff_263_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_267_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_268_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_269_rxode2parse, -2078, {1, d_reductions_269_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_270_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_271_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_272_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_273_rxode2parse, -2112, {1, d_reductions_273_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_274_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_275_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_276_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_277_rxode2parse, -712, {1, d_reductions_277_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_210_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_210_rxode2parse, d_accepts_diff_210_rxode2parse, -1}, +{d_goto_valid_268_rxode2parse, -171, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, +{d_goto_valid_269_rxode2parse, -2155, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_269_rxode2parse}, 1, NULL, (void*)d_scanner_82_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_82_rxode2parse, d_accepts_diff_82_rxode2parse, -1}, +{d_goto_valid_270_rxode2parse, -152, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, +{d_goto_valid_271_rxode2parse, -165, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, +{d_goto_valid_272_rxode2parse, -227, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_272_rxode2parse}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, +{d_goto_valid_273_rxode2parse, -142, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, +{d_goto_valid_274_rxode2parse, -198, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_274_rxode2parse}, 1, NULL, (void*)d_scanner_263_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_263_rxode2parse, d_accepts_diff_263_rxode2parse, -1}, +{d_goto_valid_275_rxode2parse, -231, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_275_rxode2parse}, 1, NULL, (void*)d_scanner_263_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_263_rxode2parse, d_accepts_diff_263_rxode2parse, -1}, +{d_goto_valid_276_rxode2parse, -198, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, +{d_goto_valid_277_rxode2parse, -307, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_68_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_68_rxode2parse, d_accepts_diff_68_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_278_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_279_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_280_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_281_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_282_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_283_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_284_rxode2parse, -783, {1, d_reductions_284_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_210_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_210_rxode2parse, d_accepts_diff_210_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_285_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_286_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_287_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_281_rxode2parse, -23, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_281_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_282_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_281_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_283_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_281_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_284_rxode2parse, -38, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_281_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_285_rxode2parse, -42, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_281_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_286_rxode2parse, -93, {1, d_reductions_286_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_286_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_287_rxode2parse, -52, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_151_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_151_rxode2parse, d_accepts_diff_151_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_288_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_289_rxode2parse, -354, {1, d_reductions_289_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_210_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_210_rxode2parse, d_accepts_diff_210_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_289_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_290_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_291_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_291_rxode2parse, -2363, {1, d_reductions_291_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_292_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_293_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_294_rxode2parse, -146, {1, d_reductions_294_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_210_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_210_rxode2parse, d_accepts_diff_210_rxode2parse, -1}, -{d_goto_valid_295_rxode2parse, -2249, {1, d_reductions_295_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_296_rxode2parse, -55, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_296_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_297_rxode2parse, -902, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_297_rxode2parse}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{d_goto_valid_298_rxode2parse, -1269, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_298_rxode2parse}, 1, NULL, (void*)d_scanner_74_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_rxode2parse, d_accepts_diff_74_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_299_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_294_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_295_rxode2parse, -2456, {1, d_reductions_295_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_296_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_297_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_298_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_299_rxode2parse, -380, {1, d_reductions_299_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_231_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_231_rxode2parse, d_accepts_diff_231_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_300_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_301_rxode2parse, -344, {1, d_reductions_301_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_210_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_210_rxode2parse, d_accepts_diff_210_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_301_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_302_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_303_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_304_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_305_rxode2parse, -410, {1, d_reductions_305_rxode2parse}, {1, d_right_epsilon_hints_305_rxode2parse}, {0, NULL}, 1, NULL, (void*)d_scanner_305_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_305_rxode2parse, d_accepts_diff_305_rxode2parse, -1}, -{d_goto_valid_306_rxode2parse, -2232, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_306_rxode2parse}, 1, NULL, (void*)d_scanner_75_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_75_rxode2parse, d_accepts_diff_75_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_307_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_307_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_305_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_306_rxode2parse, -370, {1, d_reductions_306_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_231_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_231_rxode2parse, d_accepts_diff_231_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_307_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_308_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_309_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_310_rxode2parse, 110, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_310_rxode2parse}, 1, NULL, (void*)d_scanner_310_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_310_rxode2parse, d_accepts_diff_310_rxode2parse, -1}, -{d_goto_valid_311_rxode2parse, 107, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_311_rxode2parse}, 1, NULL, (void*)d_scanner_310_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_310_rxode2parse, d_accepts_diff_310_rxode2parse, -1}, -{d_goto_valid_312_rxode2parse, -307, {1, d_reductions_312_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_76_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_76_rxode2parse, d_accepts_diff_76_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_313_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_313_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_310_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_311_rxode2parse, -594, {1, d_reductions_311_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_231_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_231_rxode2parse, d_accepts_diff_231_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_312_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_313_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_314_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_315_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_316_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_317_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_318_rxode2parse, -192, {1, d_reductions_318_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_210_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_210_rxode2parse, d_accepts_diff_210_rxode2parse, -1}, -{NULL, -2147483647, {2, d_reductions_319_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_320_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_321_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_322_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_323_rxode2parse, -65, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, +{d_goto_valid_316_rxode2parse, -409, {1, d_reductions_316_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_231_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_231_rxode2parse, d_accepts_diff_231_rxode2parse, -1}, +{d_goto_valid_317_rxode2parse, -2543, {1, d_reductions_317_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_318_rxode2parse, -56, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_318_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_319_rxode2parse, -1231, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_319_rxode2parse}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{d_goto_valid_320_rxode2parse, -1512, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_320_rxode2parse}, 1, NULL, (void*)d_scanner_81_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_81_rxode2parse, d_accepts_diff_81_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_321_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_322_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_323_rxode2parse, -340, {1, d_reductions_323_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_231_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_231_rxode2parse, d_accepts_diff_231_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_324_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_325_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_326_rxode2parse, 98, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_326_rxode2parse}, 1, NULL, (void*)d_scanner_163_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_163_rxode2parse, d_accepts_diff_163_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_327_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_328_rxode2parse, 97, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_328_rxode2parse}, 1, NULL, (void*)d_scanner_163_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_163_rxode2parse, d_accepts_diff_163_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_329_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_326_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_327_rxode2parse, -226, {1, d_reductions_327_rxode2parse}, {1, d_right_epsilon_hints_327_rxode2parse}, {0, NULL}, 1, NULL, (void*)d_scanner_327_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_327_rxode2parse, d_accepts_diff_327_rxode2parse, -1}, +{d_goto_valid_328_rxode2parse, -1770, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_328_rxode2parse}, 1, NULL, (void*)d_scanner_82_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_82_rxode2parse, d_accepts_diff_82_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_329_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_329_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_330_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_331_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_332_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_333_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_334_rxode2parse, -2419, {1, d_reductions_334_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_335_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_332_rxode2parse, 124, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_332_rxode2parse}, 1, NULL, (void*)d_scanner_332_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_332_rxode2parse, d_accepts_diff_332_rxode2parse, -1}, +{d_goto_valid_333_rxode2parse, 121, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_333_rxode2parse}, 1, NULL, (void*)d_scanner_332_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_332_rxode2parse, d_accepts_diff_332_rxode2parse, -1}, +{d_goto_valid_334_rxode2parse, -219, {1, d_reductions_334_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_83_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_83_rxode2parse, d_accepts_diff_83_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_335_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_335_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_336_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_337_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_338_rxode2parse, -2447, {1, d_reductions_338_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_338_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_339_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_340_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_341_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_342_rxode2parse, -2617, {1, d_reductions_342_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_343_rxode2parse, -2600, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_306_rxode2parse}, 1, NULL, (void*)d_scanner_75_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_75_rxode2parse, d_accepts_diff_75_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_344_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_344_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_345_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_346_rxode2parse, -2708, {1, d_reductions_346_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_347_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_347_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_348_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_340_rxode2parse, -199, {1, d_reductions_340_rxode2parse}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_231_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_231_rxode2parse, d_accepts_diff_231_rxode2parse, -1}, +{NULL, -2147483647, {2, d_reductions_341_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_342_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_343_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_344_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_345_rxode2parse, -65, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_346_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_347_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_348_rxode2parse, 111, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_348_rxode2parse}, 1, NULL, (void*)d_scanner_182_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_182_rxode2parse, d_accepts_diff_182_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_349_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_350_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_350_rxode2parse, 110, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_350_rxode2parse}, 1, NULL, (void*)d_scanner_182_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_182_rxode2parse, d_accepts_diff_182_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_351_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_352_rxode2parse, -2883, {1, d_reductions_352_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_352_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_353_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_354_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_355_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_356_rxode2parse, -2911, {1, d_reductions_356_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_357_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_357_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_358_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_357_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_359_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_357_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_360_rxode2parse, -3081, {2, d_reductions_360_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_361_rxode2parse, -3300, {1, d_reductions_361_rxode2parse}, {2, d_right_epsilon_hints_361_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_362_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_363_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_364_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_365_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_356_rxode2parse, -2670, {1, d_reductions_356_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_357_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_358_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_359_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_360_rxode2parse, -2780, {1, d_reductions_360_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {2, d_reductions_361_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_362_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_363_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_364_rxode2parse, 23, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_364_rxode2parse}, 1, NULL, (void*)d_scanner_364_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_364_rxode2parse, d_accepts_diff_364_rxode2parse, -1}, +{d_goto_valid_365_rxode2parse, -348, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_100_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_100_rxode2parse, d_accepts_diff_100_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_366_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_367_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_368_rxode2parse, -75, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_368_rxode2parse}, 1, NULL, (void*)d_scanner_133_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_133_rxode2parse, d_accepts_diff_133_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_369_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_369_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_370_rxode2parse, -74, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_370_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_371_rxode2parse, -25, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_371_rxode2parse}, 1, NULL, (void*)d_scanner_172_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_172_rxode2parse, d_accepts_diff_172_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_368_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_369_rxode2parse, -2867, {1, d_reductions_369_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_370_rxode2parse, -1924, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_328_rxode2parse}, 1, NULL, (void*)d_scanner_82_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_82_rxode2parse, d_accepts_diff_82_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_371_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_371_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_372_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_373_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_374_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_375_rxode2parse, -3435, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_144_rxode2parse}, 1, NULL, (void*)d_scanner_144_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_144_rxode2parse, d_accepts_diff_144_rxode2parse, -1}, +{d_goto_valid_373_rxode2parse, -2977, {1, d_reductions_373_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_374_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_374_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_375_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_376_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_377_rxode2parse, -3654, {1, d_reductions_377_rxode2parse}, {2, d_right_epsilon_hints_377_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_377_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_378_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_379_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_379_rxode2parse, -3104, {1, d_reductions_379_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_380_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_381_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_382_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_383_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_384_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_385_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_385_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_386_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_386_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_387_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_388_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_383_rxode2parse, -3191, {1, d_reductions_383_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_384_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_384_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_385_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_384_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_386_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_384_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_387_rxode2parse, -3284, {2, d_reductions_387_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_388_rxode2parse, -3541, {1, d_reductions_388_rxode2parse}, {2, d_right_epsilon_hints_388_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_389_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_390_rxode2parse, -3779, {1, d_reductions_390_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_391_rxode2parse, -239, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_111_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_111_rxode2parse, d_accepts_diff_111_rxode2parse, -1}, -{d_goto_valid_392_rxode2parse, -115, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_392_rxode2parse}, 1, NULL, (void*)d_scanner_243_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_243_rxode2parse, d_accepts_diff_243_rxode2parse, -1}, -{d_goto_valid_393_rxode2parse, -134, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_393_rxode2parse}, 1, NULL, (void*)d_scanner_243_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_243_rxode2parse, d_accepts_diff_243_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_390_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_391_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_392_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_393_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_394_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_395_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_396_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_397_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_398_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_395_rxode2parse, -83, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_395_rxode2parse}, 1, NULL, (void*)d_scanner_151_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_151_rxode2parse, d_accepts_diff_151_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_396_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_396_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_397_rxode2parse, -85, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_397_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_398_rxode2parse, -31, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_398_rxode2parse}, 1, NULL, (void*)d_scanner_191_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_191_rxode2parse, d_accepts_diff_191_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_399_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_400_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_401_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_402_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_402_rxode2parse, -3665, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_162_rxode2parse}, 1, NULL, (void*)d_scanner_162_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_162_rxode2parse, d_accepts_diff_162_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_403_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_404_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_404_rxode2parse, -3901, {1, d_reductions_404_rxode2parse}, {2, d_right_epsilon_hints_404_rxode2parse}, {2, d_error_recovery_hints_0_rxode2parse}, 1, NULL, (void*)d_scanner_0_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_0_rxode2parse, d_accepts_diff_0_rxode2parse, -1}, {NULL, -2147483647, {1, d_reductions_405_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_406_rxode2parse, -251, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_406_rxode2parse}, 1, NULL, (void*)d_scanner_242_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_242_rxode2parse, d_accepts_diff_242_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_406_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_407_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_408_rxode2parse, -81, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{d_goto_valid_409_rxode2parse, -3838, {1, d_reductions_409_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_410_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_410_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_411_rxode2parse, -2944, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_411_rxode2parse}, 1, NULL, (void*)d_scanner_75_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_75_rxode2parse, d_accepts_diff_75_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_412_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_413_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_414_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_415_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {2, d_reductions_416_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_417_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_418_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_419_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_420_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_421_rxode2parse, -3975, {1, d_reductions_421_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{d_goto_valid_422_rxode2parse, 83, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_422_rxode2parse}, 1, NULL, (void*)d_scanner_310_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_310_rxode2parse, d_accepts_diff_310_rxode2parse, -1}, -{d_goto_valid_423_rxode2parse, 82, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_423_rxode2parse}, 1, NULL, (void*)d_scanner_310_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_310_rxode2parse, d_accepts_diff_310_rxode2parse, -1}, -{d_goto_valid_424_rxode2parse, -4034, {1, d_reductions_424_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_425_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_425_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_408_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_409_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_410_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_411_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_412_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_412_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_413_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_413_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_414_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_415_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_416_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_417_rxode2parse, -4040, {1, d_reductions_417_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_418_rxode2parse, -309, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_122_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_122_rxode2parse, d_accepts_diff_122_rxode2parse, -1}, +{d_goto_valid_419_rxode2parse, -109, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_419_rxode2parse}, 1, NULL, (void*)d_scanner_264_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_264_rxode2parse, d_accepts_diff_264_rxode2parse, -1}, +{d_goto_valid_420_rxode2parse, -114, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_420_rxode2parse}, 1, NULL, (void*)d_scanner_264_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_264_rxode2parse, d_accepts_diff_264_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_421_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_422_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_423_rxode2parse, -91, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_423_rxode2parse}, 1, NULL, (void*)d_scanner_3_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_rxode2parse, d_accepts_diff_3_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_424_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_425_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_426_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_427_rxode2parse, -236, {1, d_reductions_427_rxode2parse}, {2, d_right_epsilon_hints_427_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_428_rxode2parse, -88, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_428_rxode2parse}, 1, NULL, (void*)d_scanner_133_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_133_rxode2parse, d_accepts_diff_133_rxode2parse, -1}, -{d_goto_valid_429_rxode2parse, -88, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_429_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_427_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_428_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_429_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_430_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_431_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_432_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_433_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_434_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_435_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_435_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_436_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_436_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_437_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{NULL, -2147483647, {1, d_reductions_438_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_439_rxode2parse, -4171, {1, d_reductions_439_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_71_rxode2parse}, 1, NULL, (void*)d_scanner_71_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_71_rxode2parse, d_accepts_diff_71_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_440_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_440_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, -{d_goto_valid_441_rxode2parse, -119, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_441_rxode2parse}, 1, NULL, (void*)d_scanner_73_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_73_rxode2parse, d_accepts_diff_73_rxode2parse, -1}, -{NULL, -2147483647, {1, d_reductions_442_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_442_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1} +{d_goto_valid_435_rxode2parse, -256, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_435_rxode2parse}, 1, NULL, (void*)d_scanner_263_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_263_rxode2parse, d_accepts_diff_263_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_436_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_437_rxode2parse, -89, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_438_rxode2parse, -4127, {1, d_reductions_438_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_439_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_439_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_440_rxode2parse, -2850, {0, NULL}, {0, NULL}, {2, d_error_recovery_hints_440_rxode2parse}, 1, NULL, (void*)d_scanner_82_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_82_rxode2parse, d_accepts_diff_82_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_441_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_442_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_443_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_444_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {2, d_reductions_445_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_446_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_447_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_448_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_449_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_450_rxode2parse, -4214, {1, d_reductions_450_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{d_goto_valid_451_rxode2parse, 94, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_451_rxode2parse}, 1, NULL, (void*)d_scanner_332_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_332_rxode2parse, d_accepts_diff_332_rxode2parse, -1}, +{d_goto_valid_452_rxode2parse, 92, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_452_rxode2parse}, 1, NULL, (void*)d_scanner_332_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_332_rxode2parse, d_accepts_diff_332_rxode2parse, -1}, +{d_goto_valid_453_rxode2parse, -463, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_453_rxode2parse}, 1, NULL, (void*)d_scanner_100_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_100_rxode2parse, d_accepts_diff_100_rxode2parse, -1}, +{d_goto_valid_454_rxode2parse, -4301, {1, d_reductions_454_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_455_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_455_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_456_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_457_rxode2parse, -225, {1, d_reductions_457_rxode2parse}, {2, d_right_epsilon_hints_457_rxode2parse}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_458_rxode2parse, -96, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_458_rxode2parse}, 1, NULL, (void*)d_scanner_151_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_151_rxode2parse, d_accepts_diff_151_rxode2parse, -1}, +{d_goto_valid_459_rxode2parse, -105, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_459_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_460_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_461_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_462_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_463_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_464_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_465_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_465_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_466_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_466_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_467_rxode2parse, -211, {1, d_reductions_467_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_467_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_468_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_469_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_470_rxode2parse, -4388, {1, d_reductions_470_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_78_rxode2parse}, 1, NULL, (void*)d_scanner_78_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_rxode2parse, d_accepts_diff_78_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_471_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_471_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{d_goto_valid_472_rxode2parse, -338, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_472_rxode2parse}, 1, NULL, (void*)d_scanner_263_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_263_rxode2parse, d_accepts_diff_263_rxode2parse, -1}, +{d_goto_valid_473_rxode2parse, -112, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_473_rxode2parse}, 1, NULL, (void*)d_scanner_80_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_80_rxode2parse, d_accepts_diff_80_rxode2parse, -1}, +{d_goto_valid_474_rxode2parse, -511, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_100_rxode2parse, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_100_rxode2parse, d_accepts_diff_100_rxode2parse, -1}, +{NULL, -2147483647, {1, d_reductions_475_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_475_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_476_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_477_rxode2parse}, {0, NULL}, {1, d_error_recovery_hints_477_rxode2parse}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, +{NULL, -2147483647, {1, d_reductions_478_rxode2parse}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1} }; D_Symbol d_symbols_rxode2parse[] = { @@ -7038,83 +7464,93 @@ D_Symbol d_symbols_rxode2parse[] = { {D_SYMBOL_EBNF, "end_statement__60", 17, -1}, {D_SYMBOL_NTERM, "assignment", 10, -1}, {D_SYMBOL_EBNF, "assignment__63", 14, -1}, +{D_SYMBOL_NTERM, "assign_str", 10, -1}, +{D_SYMBOL_EBNF, "assign_str__65", 14, -1}, +{D_SYMBOL_NTERM, "levels_str", 10, -1}, +{D_SYMBOL_INTERNAL, "levels_str__69", 14, -1}, +{D_SYMBOL_EBNF, "levels_str__68", 14, -1}, +{D_SYMBOL_EBNF, "levels_str__67", 14, -1}, +{D_SYMBOL_NTERM, "levels_str1", 11, -1}, +{D_SYMBOL_EBNF, "levels_str1__71", 15, -1}, {D_SYMBOL_NTERM, "mat0", 4, -1}, {D_SYMBOL_NTERM, "matF", 4, -1}, {D_SYMBOL_NTERM, "mtime", 5, -1}, -{D_SYMBOL_EBNF, "mtime__67", 9, -1}, +{D_SYMBOL_EBNF, "mtime__75", 9, -1}, {D_SYMBOL_NTERM, "logical_or_expression", 21, -1}, -{D_SYMBOL_INTERNAL, "logical_or_expression__71", 25, -1}, -{D_SYMBOL_EBNF, "logical_or_expression__69", 25, -1}, -{D_SYMBOL_EBNF, "logical_or_expression__69__70", 29, -1}, +{D_SYMBOL_INTERNAL, "logical_or_expression__79", 25, -1}, +{D_SYMBOL_EBNF, "logical_or_expression__77", 25, -1}, +{D_SYMBOL_EBNF, "logical_or_expression__77__78", 29, -1}, {D_SYMBOL_NTERM, "logical_and_expression", 22, -1}, -{D_SYMBOL_INTERNAL, "logical_and_expression__75", 26, -1}, -{D_SYMBOL_EBNF, "logical_and_expression__73", 26, -1}, -{D_SYMBOL_EBNF, "logical_and_expression__73__74", 30, -1}, +{D_SYMBOL_INTERNAL, "logical_and_expression__83", 26, -1}, +{D_SYMBOL_EBNF, "logical_and_expression__81", 26, -1}, +{D_SYMBOL_EBNF, "logical_and_expression__81__82", 30, -1}, {D_SYMBOL_NTERM, "equality_expression0", 20, -1}, {D_SYMBOL_NTERM, "equality_str", 12, -1}, {D_SYMBOL_NTERM, "equality_str1", 13, -1}, -{D_SYMBOL_EBNF, "equality_str1__79", 17, -1}, +{D_SYMBOL_EBNF, "equality_str1__87", 17, -1}, {D_SYMBOL_NTERM, "equality_str2", 13, -1}, -{D_SYMBOL_EBNF, "equality_str2__81", 17, -1}, +{D_SYMBOL_EBNF, "equality_str2__89", 17, -1}, {D_SYMBOL_NTERM, "equality_expression", 19, -1}, -{D_SYMBOL_INTERNAL, "equality_expression__85", 23, -1}, -{D_SYMBOL_EBNF, "equality_expression__83", 23, -1}, -{D_SYMBOL_EBNF, "equality_expression__83__84", 27, -1}, +{D_SYMBOL_INTERNAL, "equality_expression__93", 23, -1}, +{D_SYMBOL_EBNF, "equality_expression__91", 23, -1}, +{D_SYMBOL_EBNF, "equality_expression__91__92", 27, -1}, {D_SYMBOL_NTERM, "relational_op", 13, -1}, {D_SYMBOL_NTERM, "relational_expression", 21, -1}, -{D_SYMBOL_INTERNAL, "relational_expression__89", 25, -1}, -{D_SYMBOL_EBNF, "relational_expression__88", 25, -1}, +{D_SYMBOL_INTERNAL, "relational_expression__97", 25, -1}, +{D_SYMBOL_EBNF, "relational_expression__96", 25, -1}, {D_SYMBOL_NTERM, "additive_expression", 19, -1}, -{D_SYMBOL_INTERNAL, "additive_expression__93", 23, -1}, -{D_SYMBOL_EBNF, "additive_expression__91", 23, -1}, -{D_SYMBOL_EBNF, "additive_expression__91__92", 27, -1}, +{D_SYMBOL_INTERNAL, "additive_expression__101", 24, -1}, +{D_SYMBOL_EBNF, "additive_expression__99", 23, -1}, +{D_SYMBOL_EBNF, "additive_expression__99__100", 28, -1}, {D_SYMBOL_NTERM, "multiplicative_expression", 25, -1}, -{D_SYMBOL_INTERNAL, "multiplicative_expression__96", 29, -1}, -{D_SYMBOL_EBNF, "multiplicative_expression__95", 29, -1}, +{D_SYMBOL_INTERNAL, "multiplicative_expression__104", 30, -1}, +{D_SYMBOL_EBNF, "multiplicative_expression__103", 30, -1}, {D_SYMBOL_NTERM, "mult_part", 9, -1}, -{D_SYMBOL_EBNF, "mult_part__98", 13, -1}, +{D_SYMBOL_EBNF, "mult_part__106", 14, -1}, {D_SYMBOL_NTERM, "unary_expression", 16, -1}, -{D_SYMBOL_EBNF, "unary_expression__102", 21, -1}, -{D_SYMBOL_INTERNAL, "unary_expression__101", 21, -1}, -{D_SYMBOL_EBNF, "unary_expression__100", 21, -1}, +{D_SYMBOL_EBNF, "unary_expression__110", 21, -1}, +{D_SYMBOL_INTERNAL, "unary_expression__109", 21, -1}, +{D_SYMBOL_EBNF, "unary_expression__108", 21, -1}, {D_SYMBOL_NTERM, "exponent_expression", 19, -1}, -{D_SYMBOL_EBNF, "exponent_expression__106", 24, -1}, -{D_SYMBOL_INTERNAL, "exponent_expression__105", 24, -1}, -{D_SYMBOL_EBNF, "exponent_expression__104", 24, -1}, +{D_SYMBOL_EBNF, "exponent_expression__114", 24, -1}, +{D_SYMBOL_INTERNAL, "exponent_expression__113", 24, -1}, +{D_SYMBOL_EBNF, "exponent_expression__112", 24, -1}, {D_SYMBOL_NTERM, "power_expression", 16, -1}, {D_SYMBOL_NTERM, "power_operator", 14, -1}, -{D_SYMBOL_EBNF, "power_operator__109", 19, -1}, +{D_SYMBOL_EBNF, "power_operator__117", 19, -1}, {D_SYMBOL_NTERM, "primary_expression", 18, -1}, {D_SYMBOL_NTERM, "ifelse", 6, -1}, {D_SYMBOL_NTERM, "function", 8, -1}, -{D_SYMBOL_INTERNAL, "function__116", 13, -1}, -{D_SYMBOL_EBNF, "function__115", 13, -1}, -{D_SYMBOL_INTERNAL, "function__114", 13, -1}, -{D_SYMBOL_EBNF, "function__113", 13, -1}, +{D_SYMBOL_INTERNAL, "function__124", 13, -1}, +{D_SYMBOL_EBNF, "function__123", 13, -1}, +{D_SYMBOL_INTERNAL, "function__122", 13, -1}, +{D_SYMBOL_EBNF, "function__121", 13, -1}, {D_SYMBOL_NTERM, "function_name", 13, -1}, {D_SYMBOL_NTERM, "ini_const", 9, -1}, -{D_SYMBOL_INTERNAL, "ini_const__119", 14, -1}, +{D_SYMBOL_INTERNAL, "ini_const__127", 14, -1}, {D_SYMBOL_NTERM, "trans_const", 11, -1}, -{D_SYMBOL_INTERNAL, "trans_const__121", 16, -1}, +{D_SYMBOL_INTERNAL, "trans_const__129", 16, -1}, {D_SYMBOL_NTERM, "constant", 8, -1}, {D_SYMBOL_NTERM, "identifier_r", 12, -1}, {D_SYMBOL_NTERM, "identifier_r_no_output", 22, -1}, {D_SYMBOL_NTERM, "identifier_r_extra", 18, -1}, {D_SYMBOL_NTERM, "theta", 5, -1}, -{D_SYMBOL_EBNF, "theta__127", 10, -1}, +{D_SYMBOL_EBNF, "theta__135", 10, -1}, {D_SYMBOL_NTERM, "eta", 3, -1}, -{D_SYMBOL_EBNF, "eta__129", 8, -1}, +{D_SYMBOL_EBNF, "eta__137", 8, -1}, {D_SYMBOL_NTERM, "theta0", 6, -1}, -{D_SYMBOL_EBNF, "theta0__131", 11, -1}, +{D_SYMBOL_EBNF, "theta0__139", 11, -1}, {D_SYMBOL_NTERM, "theta_noout", 11, -1}, -{D_SYMBOL_EBNF, "theta_noout__133", 16, -1}, +{D_SYMBOL_EBNF, "theta_noout__141", 16, -1}, {D_SYMBOL_NTERM, "eta_noout", 9, -1}, -{D_SYMBOL_EBNF, "eta_noout__135", 14, -1}, +{D_SYMBOL_EBNF, "eta_noout__143", 14, -1}, {D_SYMBOL_NTERM, "theta0_noout", 12, -1}, -{D_SYMBOL_EBNF, "theta0_noout__137", 17, -1}, +{D_SYMBOL_EBNF, "theta0_noout__145", 17, -1}, {D_SYMBOL_NTERM, "decimalintNo0", 13, -1}, {D_SYMBOL_NTERM, "decimalint", 10, -1}, {D_SYMBOL_NTERM, "string", 6, -1}, +{D_SYMBOL_NTERM, "string1", 7, -1}, +{D_SYMBOL_NTERM, "string2", 7, -1}, {D_SYMBOL_NTERM, "float1", 6, -1}, {D_SYMBOL_NTERM, "float2", 6, -1}, {D_SYMBOL_NTERM, "identifier_r_1", 14, -1}, @@ -7123,8 +7559,8 @@ D_Symbol d_symbols_rxode2parse[] = { {D_SYMBOL_NTERM, "identifier_r_no_output_2", 24, -1}, {D_SYMBOL_NTERM, "identifier", 10, -1}, {D_SYMBOL_NTERM, "whitespace", 10, 1}, -{D_SYMBOL_INTERNAL, "whitespace__150", 15, -1}, -{D_SYMBOL_EBNF, "whitespace__149", 15, -1}, +{D_SYMBOL_INTERNAL, "whitespace__160", 15, -1}, +{D_SYMBOL_EBNF, "whitespace__159", 15, -1}, {D_SYMBOL_NTERM, "singleLineComment", 17, -1}, {D_SYMBOL_STRING, "{", 1, -1}, {D_SYMBOL_STRING, "}", 1, -1}, @@ -7225,6 +7661,25 @@ D_Symbol d_symbols_rxode2parse[] = { {D_SYMBOL_STRING, "=", 1, -1}, {D_SYMBOL_STRING, "<-", 2, -1}, {D_SYMBOL_STRING, "~", 1, -1}, +{D_SYMBOL_STRING, "=", 1, -1}, +{D_SYMBOL_STRING, "<-", 2, -1}, +{D_SYMBOL_STRING, "~", 1, -1}, +{D_SYMBOL_STRING, "levels", 6, -1}, +{D_SYMBOL_STRING, "(", 1, -1}, +{D_SYMBOL_STRING, ")", 1, -1}, +{D_SYMBOL_STRING, "=", 1, -1}, +{D_SYMBOL_STRING, "<-", 2, -1}, +{D_SYMBOL_STRING, "~", 1, -1}, +{D_SYMBOL_STRING, "c", 1, -1}, +{D_SYMBOL_STRING, "(", 1, -1}, +{D_SYMBOL_STRING, ",", 1, -1}, +{D_SYMBOL_STRING, ")", 1, -1}, +{D_SYMBOL_STRING, "levels", 6, -1}, +{D_SYMBOL_STRING, "(", 1, -1}, +{D_SYMBOL_STRING, ")", 1, -1}, +{D_SYMBOL_STRING, "=", 1, -1}, +{D_SYMBOL_STRING, "<-", 2, -1}, +{D_SYMBOL_STRING, "~", 1, -1}, {D_SYMBOL_STRING, "_rxM", 4, -1}, {D_SYMBOL_STRING, "=", 1, -1}, {D_SYMBOL_STRING, "_rxF", 4, -1}, @@ -7322,6 +7777,7 @@ D_Symbol d_symbols_rxode2parse[] = { {D_SYMBOL_REGEX, "([1-9][0-9]*)", 13, -1}, {D_SYMBOL_REGEX, "0|([1-9][0-9]*)", 15, -1}, {D_SYMBOL_REGEX, "\\\"([^\\\"\\\\\\\\]|\\\\\\\\[^])*\\\"", 38, -1}, +{D_SYMBOL_REGEX, "'([^'\\\\\\\\]|\\\\\\\\[^])*'", 29, -1}, {D_SYMBOL_REGEX, "([0-9]+.[0-9]*|[0-9]*.[0-9]+)([eE][\\\\-\\\\+]?[0-9]+)?", 55, -1}, {D_SYMBOL_REGEX, "[0-9]+[eE][\\\\-\\\\+]?[0-9]+", 29, -1}, {D_SYMBOL_REGEX, "[a-zA-Z][a-zA-Z0-9_.]*", 22, -1}, @@ -7335,4 +7791,4 @@ D_Symbol d_symbols_rxode2parse[] = { }; D_ParserTables parser_tables_rxode2parse = { -443, d_states_rxode2parse, d_gotos_rxode2parse, 1, 358, d_symbols_rxode2parse, NULL, 0, NULL, 0}; +479, d_states_rxode2parse, d_gotos_rxode2parse, 1, 388, d_symbols_rxode2parse, NULL, 0, NULL, 0}; diff --git a/src/tran.h b/src/tran.h index a3148b69d..7cb1434bc 100644 --- a/src/tran.h +++ b/src/tran.h @@ -3,7 +3,7 @@ #include #include #include -extern int rx_syntax_require_ode_first, needSort; +extern int needSort; void updateSyntaxCol(void); void trans_syntax_error_report_fn(char *err); void parseFree(int last); @@ -16,6 +16,10 @@ typedef struct symtab { vLines ss; // Symbol string or symbol lines /* char ss[64*MXSYM]; */ /* symbol string: all vars*/ vLines de; /* symbol string: all Des*/ + vLines str; /* symbol string: all assigned string variables*/ + vLines strVal; /* symbol string for rxode2 assigned strings */ + int *strValI; /* which variable is assigned a string */ + int *strValII; /* The number that the string is assigned (what C sees) */ int *lh; /* lhs symbols? =0 not LHS @@ -39,7 +43,13 @@ lhs symbols? double *iniv; /* Initial values */ int *ini0; /* state initial variable assignment =2 if there are two assignments */ int *di; /* ith of state vars */ + int *didx; + int *dprop; /* property of state vars */ + int didxn; /* nth of declared states */ + int *si; /* ith of string vars */ + int *sin; /* n values in each string var */ int *idi; /* should ith state variable be ignored 0/1 */ + int *isi; /* should ith string variable be ignored 0/1 */ int *idu; /* Has the ith state been used in a derivative expression? */ int *lag; // Lag number (if present) int *alag; // absorption lag compartments seen @@ -80,6 +90,7 @@ lhs symbols? int hasCentralCmt; int hasKa; int allocS; + int allocSV; int allocD; int matn; int matnf; @@ -97,6 +108,7 @@ lhs symbols? int thread; int lastDdt; int nLlik; + int lvlStr; } symtab; extern symtab tb; @@ -105,8 +117,6 @@ extern vLines depotLines; extern vLines centralLines; extern vLines sbPm, sbPmDt, sbNrmL; - - #define FBIO 1 #define ALAG 2 #define RATE 3 @@ -128,10 +138,12 @@ extern vLines sbPm, sbPmDt, sbNrmL; #define TMAT0 19 #define TMATF 20 #define TLIN 21 +#define TNONE 22 // new de type #define fromDDT 2 #define fromCMTprop 1 +#define fromCMT 3 #define NEEDSEMI _("lines need to end with ';'\n to match R's handling of line endings set 'options(rxode2.syntax.require.semicolon = FALSE)'") #define NOSTATE _("defined 'df(%s)/dy(%s)', but '%s' is not a state") @@ -143,6 +155,9 @@ extern vLines sbPm, sbPmDt, sbNrmL; typedef struct nodeInfo { int alag; int assignment; + int assign_str; + int levels_str; + int levels_str1; int constant; int der_rhs; int derivative; @@ -195,12 +210,16 @@ typedef struct nodeInfo { int equality_str2; int simfun_statement; int relational_op; + int string; } nodeInfo; static inline void niReset(nodeInfo *ni){ ni->mtime = -1; ni->alag = -1; ni->assignment = -1; + ni->assign_str = -1; + ni->levels_str = -1; + ni->levels_str1 = -1; ni->constant = -1; ni->der_rhs = -1; ni->derivative = -1; @@ -253,6 +272,7 @@ static inline void niReset(nodeInfo *ni){ ni->equality_str2 = -1; ni->simfun_statement = -1; ni->relational_op = -1; + ni->string = -1; } #define STRINGIFY(...) STRINGIFY_AUX(__VA_ARGS__) @@ -265,8 +285,10 @@ extern sbuf sbOut; #define notLHS 0 #define isLHS 1 +#define isLHSstr 100 #define isState 9 #define isSuppressedLHS 10 +#define isSuppressedLHSstr 110 #define isSuppressedParam 11 #define isLhsStateExtra 19 #define isLHSparam 70 @@ -274,7 +296,6 @@ extern sbuf sbOut; extern sbuf _gbuf, _mv; #define SBPTR sb.s+sb.o -#define SBTPTR sbt.s+sbt.o #define NV tb.ss.n extern char *gBuf; @@ -348,4 +369,10 @@ void _rxode2parse_unprotect(void); char *getLine (char *src, int line, int *lloc); +#define prop0 1 +#define propF 2 +#define propAlag 4 +#define propRate 8 +#define propDur 16 + #endif // __TRAN_H__ diff --git a/src/utilc.c b/src/utilc.c index 3b4a2c0a6..c9e2c7364 100644 --- a/src/utilc.c +++ b/src/utilc.c @@ -596,117 +596,23 @@ double probitInv(double alpha, double low, double high) { return _powerDi(alpha, 1.0, 6, low, high); } -SEXP _probit(SEXP xS, SEXP lowS, SEXP highS) { +SEXP _rxode2_powerD(SEXP xS, SEXP lowS, SEXP highS, SEXP lambdaS, SEXP yjS, SEXP inverseS) { int typex = TYPEOF(xS); int typelow = TYPEOF(lowS); int typehigh = TYPEOF(highS); - double low, high; - if (Rf_length(lowS) != 1){ - Rf_errorcall(R_NilValue, _("'low' must be a numeric of length 1")); - } - if (Rf_length(highS) != 1){ - Rf_errorcall(R_NilValue, _("'high' must be a numeric of length 1")); - } - if (typelow == INTSXP){ - low = (double)(INTEGER(lowS)[0]); - } else if (typelow == REALSXP) { - low = REAL(lowS)[0]; - } else { - Rf_errorcall(R_NilValue, _("'low' must be a numeric of length 1")); + int typelambda = TYPEOF(lambdaS); + int inverse = INTEGER(inverseS)[0]; + int yj = INTEGER(yjS)[0]; + double low, high, lambda; + if (Rf_length(inverseS) != 1) { + Rf_errorcall(R_NilValue, _("'inverse' must be an logical of length 1")); } - if (typehigh == INTSXP){ - high = (double)(INTEGER(highS)[0]); - } else if (typehigh == REALSXP) { - high = REAL(highS)[0]; - } else { - Rf_errorcall(R_NilValue, _("'high' must be a numeric of length 1")); - } - if (high <= low) { - Rf_errorcall(R_NilValue, _("'high' must be greater than 'low'")); - } - int lenx = Rf_length(xS); - double *xD = NULL; - int *xI = NULL; - int isD=0; - if (typex == REALSXP){ - isD=1; - xD = REAL(xS); - } else if (typex == INTSXP){ - xI = INTEGER(xS); - } - SEXP ret = PROTECT(Rf_allocVector(REALSXP, lenx)); - double *retD = REAL(ret); - if (isD){ - for (int i = lenx; i--;){ - retD[i] = probit(xD[i], low, high); - } - } else { - for (int i = lenx; i--;){ - retD[i] = probit((double)(xI[i]), low, high); - } - } - UNPROTECT(1); - return ret; -} - -SEXP _probitInv(SEXP xS, SEXP lowS, SEXP highS) { - int typex = TYPEOF(xS); - int typelow = TYPEOF(lowS); - int typehigh = TYPEOF(highS); - double low, high; - if (Rf_length(lowS) != 1){ - Rf_errorcall(R_NilValue, _("'low' must be a numeric of length 1")); - } - if (Rf_length(highS) != 1){ - Rf_errorcall(R_NilValue, _("'high' must be a numeric of length 1")); - } - if (typelow == INTSXP){ - low = (double)(INTEGER(lowS)[0]); - } else if (typelow == REALSXP) { - low = REAL(lowS)[0]; - } else { - Rf_errorcall(R_NilValue, _("'low' must be a numeric of length 1")); - } - if (typehigh == INTSXP){ - high = (double)(INTEGER(highS)[0]); - } else if (typehigh == REALSXP) { - high = REAL(highS)[0]; - } else { - Rf_errorcall(R_NilValue, _("'high' must be a numeric of length 1")); - } - if (high <= low) { - Rf_errorcall(R_NilValue, _("'high' must be greater than 'low'")); - } - int lenx = Rf_length(xS); - double *xD = NULL; - int *xI = NULL; - int isD=0; - if (typex == REALSXP){ - isD=1; - xD = REAL(xS); - } else if (typex == INTSXP){ - xI = INTEGER(xS); + if (Rf_length(yjS) != 1) { + Rf_errorcall(R_NilValue, _("'yj' must be an integer of length 1")); } - SEXP ret = PROTECT(Rf_allocVector(REALSXP, lenx)); - double *retD = REAL(ret); - if (isD){ - for (int i = lenx; i--;){ - retD[i] = probitInv(xD[i], low, high); - } - } else { - for (int i = lenx; i--;){ - retD[i] = probitInv((double)(xI[i]), low, high); - } + if (Rf_length(lambdaS) != 1){ + Rf_errorcall(R_NilValue, _("'lambda' must be a numeric of length 1")); } - UNPROTECT(1); - return ret; -} - -SEXP _logit(SEXP xS, SEXP lowS, SEXP highS) { - int typex = TYPEOF(xS); - int typelow = TYPEOF(lowS); - int typehigh = TYPEOF(highS); - double low, high; if (Rf_length(lowS) != 1){ Rf_errorcall(R_NilValue, _("'low' must be a numeric of length 1")); } @@ -730,59 +636,12 @@ SEXP _logit(SEXP xS, SEXP lowS, SEXP highS) { if (high <= low) { Rf_errorcall(R_NilValue, _("'high' must be greater than 'low'")); } - int lenx = Rf_length(xS); - double *xD = NULL; - int *xI = NULL; - int isD=0; - if (typex == REALSXP){ - isD=1; - xD = REAL(xS); - } else if (typex == INTSXP){ - xI = INTEGER(xS); - } - SEXP ret = PROTECT(Rf_allocVector(REALSXP, lenx)); - double *retD = REAL(ret); - if (isD){ - for (int i = lenx; i--;){ - retD[i] = logit(xD[i], low, high); - } + if (typelambda == INTSXP) { + lambda = (double)(INTEGER(lambdaS)[0]); + } else if (typelambda == REALSXP) { + lambda = REAL(lambdaS)[0]; } else { - for (int i = lenx; i--;){ - retD[i] = logit((double)(xI[i]), low, high); - } - } - UNPROTECT(1); - return ret; -} - - -SEXP _expit(SEXP xS, SEXP lowS, SEXP highS) { - int typex = TYPEOF(xS); - int typelow = TYPEOF(lowS); - int typehigh = TYPEOF(highS); - double low, high; - if (Rf_length(lowS) != 1){ - Rf_errorcall(R_NilValue, _("'low' must be a numeric of length 1")); - } - if (Rf_length(highS) != 1){ - Rf_errorcall(R_NilValue, _("'high' must be a numeric of length 1")); - } - if (typelow == INTSXP){ - low = (double)(INTEGER(lowS)[0]); - } else if (typelow == REALSXP) { - low = REAL(lowS)[0]; - } else { - Rf_errorcall(R_NilValue, _("'low' must be a numeric of length 1")); - } - if (typehigh == INTSXP){ - high = (double)(INTEGER(highS)[0]); - } else if (typehigh == REALSXP) { - high = REAL(highS)[0]; - } else { - Rf_errorcall(R_NilValue, _("'high' must be a numeric of length 1")); - } - if (high <= low) { - Rf_errorcall(R_NilValue, _("'high' must be greater than 'low'")); + Rf_errorcall(R_NilValue, _("'lambda' must be a numeric of length 1")); } int lenx = Rf_length(xS); double *xD = NULL; @@ -796,13 +655,25 @@ SEXP _expit(SEXP xS, SEXP lowS, SEXP highS) { } SEXP ret = PROTECT(Rf_allocVector(REALSXP, lenx)); double *retD = REAL(ret); - if (isD){ - for (int i = lenx; i--;){ - retD[i] = expit(xD[i], low, high); + if (inverse) { + if (isD) { + for (int i = lenx; i--;){ + retD[i] = _powerDi(xD[i], lambda, yj, low, high); + } + } else { + for (int i = lenx; i--;){ + retD[i] = _powerDi((double)(xI[i]), lambda, yj, low, high); + } } } else { - for (int i = lenx; i--;){ - retD[i] = expit((double)(xI[i]), low, high); + if (isD) { + for (int i = lenx; i--;){ + retD[i] = _powerD(xD[i], lambda, yj, low, high); + } + } else { + for (int i = lenx; i--;){ + retD[i] = _powerD((double)(xI[i]), lambda, yj, low, high); + } } } UNPROTECT(1); diff --git a/tests/testthat/keep-756.qs b/tests/testthat/keep-756.qs new file mode 100644 index 000000000..793e88037 Binary files /dev/null and b/tests/testthat/keep-756.qs differ diff --git a/tests/testthat/test-000-modelVars.R b/tests/testthat/test-000-modelVars.R index c2fa41864..bdb8e078e 100644 --- a/tests/testthat/test-000-modelVars.R +++ b/tests/testthat/test-000-modelVars.R @@ -20,6 +20,7 @@ d/dt(y3) = a3*y1*y2 et <- eventTable() et$add.sampling(seq(0, 20, by = 0.01)) + out <- solve(rigid, et) expect_equal(rxModelVars(rigid), rxModelVars(rigid$cmpMgr$rxDll())) diff --git a/tests/testthat/test-as-ini.R b/tests/testthat/test-as-ini.R index 7440e82ae..49f77d540 100644 --- a/tests/testthat/test-as-ini.R +++ b/tests/testthat/test-as-ini.R @@ -1,45 +1,13 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("as.ini ini expression", { - - is.ini <- function(x) { - expect_true(is.call(x)) - expect_true(identical(x[[1]], quote(`ini`))) - } - - ini <- quote(ini({ - tka <- log(1.57) - tcl <- log(2.72) - tv <- log(31.5) - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.sd <- 0.7 - })) - - is.ini(as.ini(ini)) - - l <- quote(lotri({ - tka <- log(1.57) - tcl <- log(2.72) - tv <- log(31.5) - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.sd <- 0.7 - })) - - is.ini(as.ini(l)) - - m <- lotri({ - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - }) +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("as.ini ini expression", { - is.ini(as.ini(m)) + is.ini <- function(x) { + expect_true(is.call(x)) + expect_true(identical(x[[1]], quote(`ini`))) + } - one.compartment <- function() { - ini({ + ini <- quote(ini({ tka <- log(1.57) tcl <- log(2.72) tv <- log(31.5) @@ -47,42 +15,76 @@ if (!.Call(`_rxode2_isIntel`)) { eta.cl ~ 0.3 eta.v ~ 0.1 add.sd <- 0.7 + })) + + is.ini(as.ini(ini)) + + l <- quote(lotri({ + tka <- log(1.57) + tcl <- log(2.72) + tv <- log(31.5) + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + })) + + is.ini(as.ini(l)) + + m <- lotri({ + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - cp ~ add(add.sd) - }) - } - is.ini(as.ini(one.compartment)) + is.ini(as.ini(m)) + + one.compartment <- function() { + ini({ + tka <- log(1.57) + tcl <- log(2.72) + tv <- log(31.5) + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + cp ~ add(add.sd) + }) + } - ui <- one.compartment() + is.ini(as.ini(one.compartment)) - is.ini(as.ini(ui)) + ui <- one.compartment() - is.ini(as.ini(ui$iniDf)) + is.ini(as.ini(ui)) - ini <- c("ini({", - "tka <- log(1.57)", - "tcl <- log(2.72)", - "tv <- log(31.5)", - "eta.ka ~ 0.6", - "eta.cl ~ 0.3", - "eta.v ~ 0.1", - "add.sd <- 0.7", - "})") + is.ini(as.ini(ui$iniDf)) - is.ini(as.ini(ini)) + ini <- c("ini({", + "tka <- log(1.57)", + "tcl <- log(2.72)", + "tv <- log(31.5)", + "eta.ka ~ 0.6", + "eta.cl ~ 0.3", + "eta.v ~ 0.1", + "add.sd <- 0.7", + "})") - ini <- paste(ini, collapse="\n") + is.ini(as.ini(ini)) - is.ini(as.ini(ini)) + ini <- paste(ini, collapse="\n") + is.ini(as.ini(ini)) - }) -} + + }) + } +}) diff --git a/tests/testthat/test-as-model.R b/tests/testthat/test-as-model.R index 3ce24898e..bedc5da83 100644 --- a/tests/testthat/test-as-model.R +++ b/tests/testthat/test-as-model.R @@ -1,34 +1,13 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("as.model expression", { +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("as.model expression", { - is.model <- function(x) { - expect_true(is.call(x)) - expect_true(identical(x[[1]], quote(`model`))) - } + is.model <- function(x) { + expect_true(is.call(x)) + expect_true(identical(x[[1]], quote(`model`))) + } - model <- quote(model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - cp ~ add(add.sd) - })) - - is.model(as.model(model)) - - one.compartment <- function() { - ini({ - tka <- log(1.57) - tcl <- log(2.72) - tv <- log(31.5) - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.sd <- 0.7 - }) - model({ + model <- quote(model({ ka <- exp(tka + eta.ka) cl <- exp(tcl + eta.cl) v <- exp(tv + eta.v) @@ -36,30 +15,53 @@ if (!.Call(`_rxode2_isIntel`)) { d/dt(center) = ka * depot - cl / v * center cp = center / v cp ~ add(add.sd) - }) - } + })) + + is.model(as.model(model)) + + one.compartment <- function() { + ini({ + tka <- log(1.57) + tcl <- log(2.72) + tv <- log(31.5) + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + cp ~ add(add.sd) + }) + } - is.model(as.model(one.compartment)) + is.model(as.model(one.compartment)) - ui <- one.compartment() + ui <- one.compartment() - is.model(as.model(ui)) + is.model(as.model(ui)) - model <- c("model({", - "ka <- exp(tka + eta.ka)", - "cl <- exp(tcl + eta.cl)", - "v <- exp(tv + eta.v)", - "d/dt(depot) = -ka * depot", - "d/dt(center) = ka * depot - cl / v * center", - "cp = center / v", - "cp ~ add(add.sd)", - "})") + model <- c("model({", + "ka <- exp(tka + eta.ka)", + "cl <- exp(tcl + eta.cl)", + "v <- exp(tv + eta.v)", + "d/dt(depot) = -ka * depot", + "d/dt(center) = ka * depot - cl / v * center", + "cp = center / v", + "cp ~ add(add.sd)", + "})") - is.model(as.model(model)) + is.model(as.model(model)) - model <- paste(model, collapse="\n") + model <- paste(model, collapse="\n") - is.model(as.model(model)) + is.model(as.model(model)) - }) -} + }) + } +}) diff --git a/tests/testthat/test-assert.R b/tests/testthat/test-assert.R index 96c66bcbb..5a497de93 100644 --- a/tests/testthat/test-assert.R +++ b/tests/testthat/test-assert.R @@ -1,5 +1,31 @@ if (!.Call(`_rxode2_isIntel`)) { - test_that("assert or testRxLinCmt", { + + test_that("no warnings/errors without boundaries", { + + one.cmt <- function() { + ini({ + tka <- 0.45; label("Ka") + tcl <- log(2.7); label("Cl") + tv <- 3.45; label("V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } + + expect_true(testRxUnbounded(one.cmt)) + expect_error(assertRxUnbounded(one.cmt), NA) + expect_warning(warnRxBounded(one.cmt), NA) + }) + test_that("assert or testRxLinCmt and boundaries", { + one.cmt <- function() { ini({ tka <- 0.45; label("Ka") @@ -18,6 +44,10 @@ if (!.Call(`_rxode2_isIntel`)) { }) } + expect_false(testRxUnbounded(one.cmt)) + expect_error(assertRxUnbounded(one.cmt)) + expect_warning(warnRxBounded(one.cmt)) + expect_error(assertRxLinCmt(one.cmt), NA) expect_true(testRxLinCmt(one.cmt)) diff --git a/tests/testthat/test-backward.R b/tests/testthat/test-backward.R index c974f1db5..b4c331b03 100644 --- a/tests/testthat/test-backward.R +++ b/tests/testthat/test-backward.R @@ -173,7 +173,7 @@ expect_error(rxode2("cp<-cent/vc;d/dt(gutcp)<--ka*gutcp;d/dt(cent)<-(ka*gutcp)-q expect_equal(as.numeric(tmp$time[2]), 0.5) expect_equal(as.numeric(x$time[2]), 1) ## $ access updates object. - x$add.sampling(0.5) + expect_warning(x$add.sampling(0.5), NA) # from issue #750 expect_equal(as.numeric(x$time[2]), 0.5) }) x <- solve(mod1, theta, ev, inits) diff --git a/tests/testthat/test-binomProb.R b/tests/testthat/test-binomProb.R index 204d02a12..f4a70ce0d 100644 --- a/tests/testthat/test-binomProb.R +++ b/tests/testthat/test-binomProb.R @@ -1,156 +1,158 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("test binomProb()", { - - x <- rbinom(1001, 1, prob = 0.05) - m <- mean(x) - v <- m * (1 - m) - s <- sqrt(v) - - n <- 1001 - z <- qnorm(1 - 0.025) - z2 <- z * z - c1 <- 2*n*m + z2 - c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 - c3 <- 2*(n+z2) - z2.5 <- (c1 + c(-1, 1) * c2) / c3 - - n <- 1001 - z <- qnorm(1 - 0.05) - z2 <- z * z - c1 <- 2*n*m + z2 - c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 - c3 <- 2*(n+z2) - z5 <- (c1 + c(-1, 1) * c2) / c3 - - - t1 <- c("2.5%"=z2.5[1], - "5%"=z5[1], - "50%"=m, - "95%"=z5[2], - "97.5%"=z2.5[2]) - expect_equal(binomProbs(x, ciMethod="wilsonCorrect"), t1) - expect_equal(binomProbs(x, ciMethod="wc"), t1) - - t2 <- c(c("mean"=m, "var"=v, "sd"=s, "n"=n), t1) - expect_equal(binomProbs(x, onlyProbs=FALSE, ciMethod="wilsonCorrect"), t2) - - x2 <- c(x, NA_real_) - setNames(rep(NA_real_, length(t1)),names(t1)) - expect_equal(binomProbs(x2, ciMethod="wilsonCorrect"), - setNames(rep(NA_real_, length(t1)),names(t1))) - - expect_equal(binomProbs(x2, onlyProbs=FALSE, ciMethod="wilsonCorrect"), - setNames(rep(NA_real_, length(t2)),names(t2))) - expect_equal(binomProbs(x2,na.rm=TRUE, ciMethod="wilsonCorrect"), t1) - expect_equal(binomProbs(x2, onlyProbs=FALSE, na.rm=TRUE, ciMethod="wilsonCorrect"), t2) - - - n <- 50 - z <- qnorm(1 - 0.025) - z2 <- z * z - c1 <- 2*n*m + z2 - c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 - c3 <- 2*(n+z2) - z2.5 <- (c1 + c(-1, 1) * c2) / c3 - - n <- 50 - z <- qnorm(1 - 0.05) - z2 <- z * z - c1 <- 2*n*m + z2 - c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 - c3 <- 2*(n+z2) - z5 <- (c1 + c(-1, 1) * c2) / c3 - - - t1 <- c("2.5%"=z2.5[1], - "5%"=z5[1], - "50%"=m, - "95%"=z5[2], - "97.5%"=z2.5[2]) - - expect_equal(binomProbs(x, n=50, ciMethod="wilsonCorrect"), t1) - - # now wilson - x <- rbinom(1001, 1, prob = 0.05) - - getVals <- function(x, a=0.025) { - p <- mean(x) - n <- length(x) - z <- qnorm(1 - a) - z2 <- z ^ 2 - c0 <- 1.0 / (1.0 + z2 / n) - c1 <- c0 * (p + z2 / (2 * n)) - c2 <- z * c0 * sqrt(p * (1 - p) / n + z2 / (4 * n * n)) - (c1 + c(-1, 1) * c2) - } - - m <- mean(x) - z2.5 <- getVals(x, 0.025) - z5 <- getVals(x, 0.05) - - t1 <- c("2.5%"=z2.5[1], - "5%"=z5[1], - "50%"=m, - "95%"=z5[2], - "97.5%"=z2.5[2]) - - expect_equal(binomProbs(x, ciMethod="wilson"), t1) - - # wald - x <- rbinom(1001, 1, prob = 0.05) - - getVals <- function(x, a=0.025) { - p <- mean(x) - n <- length(x) - z <- qnorm(1 - a) - c1 <- p - c2 <- z * sqrt(p * (1 - p) / n) - (c1 + c(-1, 1) * c2) - } - - m <- mean(x) - z2.5 <- getVals(x, 0.025) - z5 <- getVals(x, 0.05) - - t1 <- c("2.5%"=z2.5[1], - "5%"=z5[1], - "50%"=m, - "95%"=z5[2], - "97.5%"=z2.5[2]) - - expect_equal(binomProbs(x, ciMethod="wald"), t1) - - # Agresti-Coull - x <- rbinom(1001, 1, prob = 0.05) - - getVals <- function(x, a=0.025) { - p <- mean(x) - n <- length(x) - z <- qnorm(1 - a) - z2 <- z ^ 2 - nh <- n + z2 - ns <- p * n - ph <- 1 / nh * (ns + z2 / 2) - c1 <- ph - c2 <- z * sqrt(ph * (1 - ph) / nh) - (c1 + c(-1, 1) * c2) - } - - m <- mean(x) - z2.5 <- getVals(x, 0.025) - z5 <- getVals(x, 0.05) - - t1 <- c("2.5%"=z2.5[1], - "5%"=z5[1], - "50%"=m, - "95%"=z5[2], - "97.5%"=z2.5[2]) - - expect_equal(binomProbs(x, ciMethod="agrestiCoull"), t1) - expect_equal(binomProbs(x, ciMethod="ac"), t1) - - - expect_equal(names(binomProbs(x, pred=TRUE)), names(binomProbs(x))) - - }) -} +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("test binomProb()", { + + x <- rbinom(1001, 1, prob = 0.05) + m <- mean(x) + v <- m * (1 - m) + s <- sqrt(v) + + n <- 1001 + z <- qnorm(1 - 0.025) + z2 <- z * z + c1 <- 2*n*m + z2 + c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 + c3 <- 2*(n+z2) + z2.5 <- (c1 + c(-1, 1) * c2) / c3 + + n <- 1001 + z <- qnorm(1 - 0.05) + z2 <- z * z + c1 <- 2*n*m + z2 + c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 + c3 <- 2*(n+z2) + z5 <- (c1 + c(-1, 1) * c2) / c3 + + + t1 <- c("2.5%"=z2.5[1], + "5%"=z5[1], + "50%"=m, + "95%"=z5[2], + "97.5%"=z2.5[2]) + expect_equal(binomProbs(x, ciMethod="wilsonCorrect"), t1) + expect_equal(binomProbs(x, ciMethod="wc"), t1) + + t2 <- c(c("mean"=m, "var"=v, "sd"=s, "n"=n), t1) + expect_equal(binomProbs(x, onlyProbs=FALSE, ciMethod="wilsonCorrect"), t2) + + x2 <- c(x, NA_real_) + setNames(rep(NA_real_, length(t1)),names(t1)) + expect_equal(binomProbs(x2, ciMethod="wilsonCorrect"), + setNames(rep(NA_real_, length(t1)),names(t1))) + + expect_equal(binomProbs(x2, onlyProbs=FALSE, ciMethod="wilsonCorrect"), + setNames(rep(NA_real_, length(t2)),names(t2))) + expect_equal(binomProbs(x2,na.rm=TRUE, ciMethod="wilsonCorrect"), t1) + expect_equal(binomProbs(x2, onlyProbs=FALSE, na.rm=TRUE, ciMethod="wilsonCorrect"), t2) + + + n <- 50 + z <- qnorm(1 - 0.025) + z2 <- z * z + c1 <- 2*n*m + z2 + c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 + c3 <- 2*(n+z2) + z2.5 <- (c1 + c(-1, 1) * c2) / c3 + + n <- 50 + z <- qnorm(1 - 0.05) + z2 <- z * z + c1 <- 2*n*m + z2 + c2 <- z*sqrt(z2 - 1.0/n + 4*n*v + (4.0*m-2.0))+1.0 + c3 <- 2*(n+z2) + z5 <- (c1 + c(-1, 1) * c2) / c3 + + + t1 <- c("2.5%"=z2.5[1], + "5%"=z5[1], + "50%"=m, + "95%"=z5[2], + "97.5%"=z2.5[2]) + + expect_equal(binomProbs(x, n=50, ciMethod="wilsonCorrect"), t1) + + # now wilson + x <- rbinom(1001, 1, prob = 0.05) + + getVals <- function(x, a=0.025) { + p <- mean(x) + n <- length(x) + z <- qnorm(1 - a) + z2 <- z ^ 2 + c0 <- 1.0 / (1.0 + z2 / n) + c1 <- c0 * (p + z2 / (2 * n)) + c2 <- z * c0 * sqrt(p * (1 - p) / n + z2 / (4 * n * n)) + (c1 + c(-1, 1) * c2) + } + + m <- mean(x) + z2.5 <- getVals(x, 0.025) + z5 <- getVals(x, 0.05) + + t1 <- c("2.5%"=z2.5[1], + "5%"=z5[1], + "50%"=m, + "95%"=z5[2], + "97.5%"=z2.5[2]) + + expect_equal(binomProbs(x, ciMethod="wilson"), t1) + + # wald + x <- rbinom(1001, 1, prob = 0.05) + + getVals <- function(x, a=0.025) { + p <- mean(x) + n <- length(x) + z <- qnorm(1 - a) + c1 <- p + c2 <- z * sqrt(p * (1 - p) / n) + (c1 + c(-1, 1) * c2) + } + + m <- mean(x) + z2.5 <- getVals(x, 0.025) + z5 <- getVals(x, 0.05) + + t1 <- c("2.5%"=z2.5[1], + "5%"=z5[1], + "50%"=m, + "95%"=z5[2], + "97.5%"=z2.5[2]) + + expect_equal(binomProbs(x, ciMethod="wald"), t1) + + # Agresti-Coull + x <- rbinom(1001, 1, prob = 0.05) + + getVals <- function(x, a=0.025) { + p <- mean(x) + n <- length(x) + z <- qnorm(1 - a) + z2 <- z ^ 2 + nh <- n + z2 + ns <- p * n + ph <- 1 / nh * (ns + z2 / 2) + c1 <- ph + c2 <- z * sqrt(ph * (1 - ph) / nh) + (c1 + c(-1, 1) * c2) + } + + m <- mean(x) + z2.5 <- getVals(x, 0.025) + z5 <- getVals(x, 0.05) + + t1 <- c("2.5%"=z2.5[1], + "5%"=z5[1], + "50%"=m, + "95%"=z5[2], + "97.5%"=z2.5[2]) + + expect_equal(binomProbs(x, ciMethod="agrestiCoull"), t1) + expect_equal(binomProbs(x, ciMethod="ac"), t1) + + + expect_equal(names(binomProbs(x, pred=TRUE)), names(binomProbs(x))) + + }) + } +}) diff --git a/tests/testthat/test-cholperm.R b/tests/testthat/test-cholperm.R index 67050b419..fa11ae1a2 100644 --- a/tests/testthat/test-cholperm.R +++ b/tests/testthat/test-cholperm.R @@ -1,344 +1,346 @@ -# These functions are taken from TruncatedNormal for testing -.rx <- loadNamespace("rxode2") - -lnNpr <- - function(a, b) { ## computes ln(P(aa>0 - I <- a > 0 - if (any(I)) { - pa <- pnorm(a[I], lower.tail = FALSE, log.p = TRUE) - pb <- pnorm(b[I], lower.tail = FALSE, log.p = TRUE) - p[I] <- pa + log1p(-exp(pb - pa)) - } - ## case a 2) { - s <- D[I] - L[I, 1:(j - 1)]^2 %*% rep(1, j - 1) - } else if (j == 2) { - s <- D[I] - L[I, 1]^2 - } else { - s <- D[I] +rxTest({ + # These functions are taken from TruncatedNormal for testing + .rx <- loadNamespace("rxode2") + + lnNpr <- + function(a, b) { ## computes ln(P(aa>0 + I <- a > 0 + if (any(I)) { + pa <- pnorm(a[I], lower.tail = FALSE, log.p = TRUE) + pb <- pnorm(b[I], lower.tail = FALSE, log.p = TRUE) + p[I] <- pa + log1p(-exp(pb - pa)) } - s[s < 0] <- eps - s <- sqrt(s) - if (j > 2) { - cols <- L[I, 1:(j - 1)] %*% z[1:(j - 1)] - } else if (j == 2) { - cols <- L[I, 1] * z[1] - } else { - cols <- 0 + ## case aj - jk <- c(j, k) - kj <- c(k, j) - Sig[jk, ] <- Sig[kj, ] - Sig[, jk] <- Sig[, kj] # update rows and cols of Sig - L[jk, ] <- L[kj, ] # update only rows of L - l[jk] <- l[kj] - u[jk] <- u[kj] # update integration limits - perm[jk] <- perm[kj] # keep track of permutation - # construct L sequentially via Cholesky computation - s <- Sig[j, j] - sum(L[j, 1:(j - 1)]^2) - if (s < (-0.001)) { - stop("Sigma is not positive semi-definite") + ## case a<0 2) { - L[(j + 1):d, j] <- (Sig[(j + 1):d, j] - L[(j + 1):d, 1:(j - 1)] %*% L[j, 1:(j - 1)]) / L[j, j] + s <- D[I] - L[I, 1:(j - 1)]^2 %*% rep(1, j - 1) } else if (j == 2) { - L[(j + 1):d, j] <- (Sig[(j + 1):d, j] - L[(j + 1):d, 1] * L[j, 1]) / L[j, j] - } else if (j == 1) { - L[(j + 1):d, j] <- Sig[(j + 1):d, j] / L[j, j] + s <- D[I] - L[I, 1]^2 + } else { + s <- D[I] } + s[s < 0] <- eps + s <- sqrt(s) + if (j > 2) { + cols <- L[I, 1:(j - 1)] %*% z[1:(j - 1)] + } else if (j == 2) { + cols <- L[I, 1] * z[1] + } else { + cols <- 0 + } + tl <- (l[I] - cols) / s + tu <- (u[I] - cols) / s + pr[I] <- lnNpr(tl, tu) + # find smallest marginal dimension + k <- which.min(pr) + # flip dimensions k-->j + jk <- c(j, k) + kj <- c(k, j) + Sig[jk, ] <- Sig[kj, ] + Sig[, jk] <- Sig[, kj] # update rows and cols of Sig + L[jk, ] <- L[kj, ] # update only rows of L + l[jk] <- l[kj] + u[jk] <- u[kj] # update integration limits + perm[jk] <- perm[kj] # keep track of permutation + # construct L sequentially via Cholesky computation + s <- Sig[j, j] - sum(L[j, 1:(j - 1)]^2) + if (s < (-0.001)) { + stop("Sigma is not positive semi-definite") + } + s[s < 0] <- eps + L[j, j] <- sqrt(s) + if (j < d) { + if (j > 2) { + L[(j + 1):d, j] <- (Sig[(j + 1):d, j] - L[(j + 1):d, 1:(j - 1)] %*% L[j, 1:(j - 1)]) / L[j, j] + } else if (j == 2) { + L[(j + 1):d, j] <- (Sig[(j + 1):d, j] - L[(j + 1):d, 1] * L[j, 1]) / L[j, j] + } else if (j == 1) { + L[(j + 1):d, j] <- Sig[(j + 1):d, j] / L[j, j] + } + } + ## find mean value, z(j), of truncated normal: + tl <- (l[j] - L[j, 1:j] %*% z[1:j]) / L[j, j] + tu <- (u[j] - L[j, 1:j] %*% z[1:j]) / L[j, j] + w <- lnNpr(tl, tu) # aids in computing expected value of trunc. normal + z[j] <- (exp(-.5 * tl^2 - w) - exp(-.5 * tu^2 - w)) / sqrt(2 * pi) } - ## find mean value, z(j), of truncated normal: - tl <- (l[j] - L[j, 1:j] %*% z[1:j]) / L[j, j] - tu <- (u[j] - L[j, 1:j] %*% z[1:j]) / L[j, j] - w <- lnNpr(tl, tu) # aids in computing expected value of trunc. normal - z[j] <- (exp(-.5 * tl^2 - w) - exp(-.5 * tu^2 - w)) / sqrt(2 * pi) + return(list(L = L, l = l, u = u, perm = perm)) } - return(list(L = L, l = l, u = u, perm = perm)) - } - -gradpsi <- - function(y, L, l, u) { # implements grad_psi(x) to find optimal exponential twisting; - # assume scaled 'L' with zero diagonal; - d <- length(u) - c <- rep(0, d) - x <- c - mu <- c - x[1:(d - 1)] <- y[1:(d - 1)] - mu[1:(d - 1)] <- y[d:(2 * d - 2)] - # compute now ~l and ~u - c[-1] <- L[-1, ] %*% x - lt <- l - mu - c - ut <- u - mu - c - # compute gradients avoiding catastrophic cancellation - w <- lnNpr(lt, ut) - pl <- exp(-0.5 * lt^2 - w) / sqrt(2 * pi) - pu <- exp(-0.5 * ut^2 - w) / sqrt(2 * pi) - P <- pl - pu - # output the gradient - dfdx <- -mu[-d] + t(t(P) %*% L[, -d]) - dfdm <- mu - x + P - grad <- c(dfdx, dfdm[-d]) - # here compute Jacobian matrix - lt[is.infinite(lt)] <- 0 - ut[is.infinite(ut)] <- 0 - dP <- (-P^2) + lt * pl - ut * pu # dPdm - DL <- rep(dP, 1, d) * L - mx <- -diag(d) + DL - xx <- t(L) %*% DL - mx <- mx[1:(d - 1), 1:(d - 1)] - xx <- xx[1:(d - 1), 1:(d - 1)] - if (d > 2) { - Jac <- rbind(cbind(xx, t(mx)), cbind(mx, diag(1 + dP[1:(d - 1)]))) - } else { - Jac <- rbind(cbind(xx, t(mx)), cbind(mx, 1 + dP[1:(d - 1)])) - dimnames(Jac) <- NULL + + gradpsi <- + function(y, L, l, u) { # implements grad_psi(x) to find optimal exponential twisting; + # assume scaled 'L' with zero diagonal; + d <- length(u) + c <- rep(0, d) + x <- c + mu <- c + x[1:(d - 1)] <- y[1:(d - 1)] + mu[1:(d - 1)] <- y[d:(2 * d - 2)] + # compute now ~l and ~u + c[-1] <- L[-1, ] %*% x + lt <- l - mu - c + ut <- u - mu - c + # compute gradients avoiding catastrophic cancellation + w <- lnNpr(lt, ut) + pl <- exp(-0.5 * lt^2 - w) / sqrt(2 * pi) + pu <- exp(-0.5 * ut^2 - w) / sqrt(2 * pi) + P <- pl - pu + # output the gradient + dfdx <- -mu[-d] + t(t(P) %*% L[, -d]) + dfdm <- mu - x + P + grad <- c(dfdx, dfdm[-d]) + # here compute Jacobian matrix + lt[is.infinite(lt)] <- 0 + ut[is.infinite(ut)] <- 0 + dP <- (-P^2) + lt * pl - ut * pu # dPdm + DL <- rep(dP, 1, d) * L + mx <- -diag(d) + DL + xx <- t(L) %*% DL + mx <- mx[1:(d - 1), 1:(d - 1)] + xx <- xx[1:(d - 1), 1:(d - 1)] + if (d > 2) { + Jac <- rbind(cbind(xx, t(mx)), cbind(mx, diag(1 + dP[1:(d - 1)]))) + } else { + Jac <- rbind(cbind(xx, t(mx)), cbind(mx, 1 + dP[1:(d - 1)])) + dimnames(Jac) <- NULL + } + f <- list(grad = grad, Jac = Jac) } - f <- list(grad = grad, Jac = Jac) - } - -nleq <- - function(l, u, L) { - d <- length(l) - x <- rep(0, 2 * d - 2) # initial point for Newton iteration - err <- Inf - iter <- 0 - while (err > 10^-10) { - f <- gradpsi(x, L, l, u) - Jac <- f$Jac - grad <- f$grad - del <- solve(Jac, -grad) # Newton correction - x <- x + del - err <- sum(grad^2) - iter <- iter + 1 - if (iter > 100) { - stop("Covariance matrix is ill-conditioned and method failed") + + nleq <- + function(l, u, L) { + d <- length(l) + x <- rep(0, 2 * d - 2) # initial point for Newton iteration + err <- Inf + iter <- 0 + while (err > 10^-10) { + f <- gradpsi(x, L, l, u) + Jac <- f$Jac + grad <- f$grad + del <- solve(Jac, -grad) # Newton correction + x <- x + del + err <- sum(grad^2) + iter <- iter + 1 + if (iter > 100) { + stop("Covariance matrix is ill-conditioned and method failed") + } } + return(x) } - return(x) - } -test_that("cholperm", { + test_that("cholperm", { - rxWithSeed(12, { - d <- 5 + rxWithSeed(12, { + d <- 5 - mu <- 1:d + mu <- 1:d - ## Creating covariance matrix - tmp <- matrix(rnorm(d^2), d, d) - mcov <- tcrossprod(tmp, tmp) + ## Creating covariance matrix + tmp <- matrix(rnorm(d^2), d, d) + mcov <- tcrossprod(tmp, tmp) - r1 <- cholperm(mcov, -(1:5), 1:5) - r2 <- .rx$rxCholperm(mcov, -(1:5), 1:5) + r1 <- cholperm(mcov, -(1:5), 1:5) + r2 <- .rx$rxCholperm(mcov, -(1:5), 1:5) - expect_equal(r1$L, r2$L) - expect_equal(r1$l, r2$l) - expect_equal(r1$u, r2$u) - expect_equal(r1$perm, r2$perm + 1) + expect_equal(r1$L, r2$L) + expect_equal(r1$l, r2$l) + expect_equal(r1$u, r2$u) + expect_equal(r1$perm, r2$perm + 1) - r1 <- cholperm(mcov, 1:5, 2 * (1:5)) - r2 <- .rx$rxCholperm(mcov, 1:5, 2 * 1:5) + r1 <- cholperm(mcov, 1:5, 2 * (1:5)) + r2 <- .rx$rxCholperm(mcov, 1:5, 2 * 1:5) - expect_equal(r1$L, r2$L) - expect_equal(r1$l, r2$l) - expect_equal(r1$u, r2$u) - expect_equal(r1$perm, r2$perm + 1) + expect_equal(r1$L, r2$L) + expect_equal(r1$l, r2$l) + expect_equal(r1$u, r2$u) + expect_equal(r1$perm, r2$perm + 1) - r1 <- cholperm(mcov, -2 * (1:5), -(1:5)) - r2 <- .rx$rxCholperm(mcov, -2 * (1:5), -(1:5)) + r1 <- cholperm(mcov, -2 * (1:5), -(1:5)) + r2 <- .rx$rxCholperm(mcov, -2 * (1:5), -(1:5)) - expect_equal(r1$L, r2$L) - expect_equal(r1$l, r2$l) - expect_equal(r1$u, r2$u) - expect_equal(r1$perm, r2$perm + 1) + expect_equal(r1$L, r2$L) + expect_equal(r1$l, r2$l) + expect_equal(r1$u, r2$u) + expect_equal(r1$perm, r2$perm + 1) + + ## microbenchmark::microbenchmark(cholperm(mcov, -2 * (1:5), -(1:5)), rxCholperm(mcov, -2 * (1:5), -(1:5))) + ## microbenchmark::microbenchmark(microbenchmark::cholperm(mcov, -2 * (1:5), -(1:5)), rxCholperm(mcov, -2 * (1:5), -(1:5))) + }) - ## microbenchmark::microbenchmark(cholperm(mcov, -2 * (1:5), -(1:5)), rxCholperm(mcov, -2 * (1:5), -(1:5))) - ## microbenchmark::microbenchmark(microbenchmark::cholperm(mcov, -2 * (1:5), -(1:5)), rxCholperm(mcov, -2 * (1:5), -(1:5))) }) -}) + test_that("gradpsi", { -test_that("gradpsi", { + rxWithSeed(12, { + d <- 5 - rxWithSeed(12, { - d <- 5 + mu <- 1:d - mu <- 1:d + ## Creating covariance matrix + tmp <- matrix(rnorm(d^2), d, d) + mcov <- tcrossprod(tmp, tmp) + r2 <- .rx$rxCholperm(mcov, -(1:5), 1:5) - ## Creating covariance matrix - tmp <- matrix(rnorm(d^2), d, d) - mcov <- tcrossprod(tmp, tmp) - r2 <- .rx$rxCholperm(mcov, -(1:5), 1:5) + d <- length(r2$l) + y <- seq(0, 2 * d - 2) + l <- r2$l + u <- r2$u + L <- r2$L - d <- length(r2$l) - y <- seq(0, 2 * d - 2) - l <- r2$l - u <- r2$u - L <- r2$L + r1 <- gradpsi(y, L, l, u) + r2 <- .rx$rxGradpsi(y, L, l, u) - r1 <- gradpsi(y, L, l, u) - r2 <- .rx$rxGradpsi(y, L, l, u) + expect_equal(r1$Jac, r2$Jac) + expect_equal(r1$grad, r2$grad) - expect_equal(r1$Jac, r2$Jac) - expect_equal(r1$grad, r2$grad) + r1 <- gradpsi(rep(1, 2 * d - 2), L, l, u) + r2 <- .rx$rxGradpsi(rep(1, 2 * d - 2), L, l, u) - r1 <- gradpsi(rep(1, 2 * d - 2), L, l, u) - r2 <- .rx$rxGradpsi(rep(1, 2 * d - 2), L, l, u) + expect_equal(r1$Jac, r2$Jac) + expect_equal(r1$grad, r2$grad) - expect_equal(r1$Jac, r2$Jac) - expect_equal(r1$grad, r2$grad) + r1 <- gradpsi(rep(-1, 2 * d - 2), L, l, u) + r2 <- .rx$rxGradpsi(rep(-1, 2 * d - 2), L, l, u) - r1 <- gradpsi(rep(-1, 2 * d - 2), L, l, u) - r2 <- .rx$rxGradpsi(rep(-1, 2 * d - 2), L, l, u) + expect_equal(r1$Jac, r2$Jac) + expect_equal(r1$grad, r2$grad) - expect_equal(r1$Jac, r2$Jac) - expect_equal(r1$grad, r2$grad) + ## microbenchmark::microbenchmark(gradpsi(rep(-1,2*d-2), L, l, u), .rx$rxGradpsi(rep(-1,2*d-2), L, l, u)); - ## microbenchmark::microbenchmark(gradpsi(rep(-1,2*d-2), L, l, u), .rx$rxGradpsi(rep(-1,2*d-2), L, l, u)); + d <- 2 - d <- 2 + mu <- 1:d - mu <- 1:d + ## Creating covariance matrix + tmp <- matrix(rnorm(d^2), d, d) + mcov <- tcrossprod(tmp, tmp) + r2 <- .rx$rxCholperm(mcov, -(1:d), 1:d) - ## Creating covariance matrix - tmp <- matrix(rnorm(d^2), d, d) - mcov <- tcrossprod(tmp, tmp) - r2 <- .rx$rxCholperm(mcov, -(1:d), 1:d) + d <- length(r2$l) + y <- seq(0, 2 * d - 2) + l <- r2$l + u <- r2$u + L <- r2$L - d <- length(r2$l) - y <- seq(0, 2 * d - 2) - l <- r2$l - u <- r2$u - L <- r2$L + r1 <- gradpsi(rep(-1, 2 * d - 2), L, l, u) + r2 <- .rx$rxGradpsi(rep(-1, 2 * d - 2), L, l, u) - r1 <- gradpsi(rep(-1, 2 * d - 2), L, l, u) - r2 <- .rx$rxGradpsi(rep(-1, 2 * d - 2), L, l, u) + expect_equal(r1$Jac, r2$Jac) + expect_equal(r1$grad, r2$grad) + }) - expect_equal(r1$Jac, r2$Jac) - expect_equal(r1$grad, r2$grad) }) -}) + test_that("nleq", { -test_that("nleq", { + rxWithSeed(12, { + d <- 5 - rxWithSeed(12, { - d <- 5 + mu <- 1:d - mu <- 1:d + ## Creating covariance matrix + tmp <- matrix(rnorm(d^2), d, d) + mcov <- tcrossprod(tmp, tmp) + r2 <- .rx$rxCholperm(mcov, -3 * (1:d), 2 * (1:d)) - ## Creating covariance matrix - tmp <- matrix(rnorm(d^2), d, d) - mcov <- tcrossprod(tmp, tmp) - r2 <- .rx$rxCholperm(mcov, -3 * (1:d), 2 * (1:d)) + expect_equal(.rx$rxNleq(r2$l, r2$u, r2$L), nleq(r2$l, r2$u, r2$L)) + ## microbenchmark::microbenchmark(rxNleq(r2$l, r2$u, r2$L), nleq(r2$l, r2$u, r2$L)) - expect_equal(.rx$rxNleq(r2$l, r2$u, r2$L), nleq(r2$l, r2$u, r2$L)) - ## microbenchmark::microbenchmark(rxNleq(r2$l, r2$u, r2$L), nleq(r2$l, r2$u, r2$L)) + d <- 2 - d <- 2 + mu <- 1:d - mu <- 1:d + ## Creating covariance matrix + tmp <- matrix(rnorm(d^2), d, d) + mcov <- tcrossprod(tmp, tmp) + r2 <- .rx$rxCholperm(mcov, -2 * (1:d), 3 * 1:d) - ## Creating covariance matrix - tmp <- matrix(rnorm(d^2), d, d) - mcov <- tcrossprod(tmp, tmp) - r2 <- .rx$rxCholperm(mcov, -2 * (1:d), 3 * 1:d) + expect_equal(.rx$rxNleq(r2$l, r2$u, r2$L), nleq(r2$l, r2$u, r2$L)) + }) - expect_equal(.rx$rxNleq(r2$l, r2$u, r2$L), nleq(r2$l, r2$u, r2$L)) }) -}) + test_that("rxMvnrnd", { -test_that("rxMvnrnd", { + rxWithSeed(12, { + d <- 5 - rxWithSeed(12, { - d <- 5 + mu <- 1:d - mu <- 1:d + ## Creating covariance matrix + tmp <- matrix(rnorm(d^2), d, d) + mcov <- tcrossprod(tmp, tmp) - ## Creating covariance matrix - tmp <- matrix(rnorm(d^2), d, d) - mcov <- tcrossprod(tmp, tmp) + out <- .rx$rxCholperm(mcov, -2 * (1:5), 1:5) - out <- .rx$rxCholperm(mcov, -2 * (1:5), 1:5) + Lfull <- out$L + l <- out$l + u <- out$u + D <- diag(Lfull) + perm <- out$perm + if (any(D < 10^-10)) { + warning("Method may fail as covariance matrix is singular!") + } + L <- Lfull / D + u <- u / D + l <- l / D # rescale + L <- L - diag(d) # remove diagonal + # find optimal tilting parameter via non-linear equation solver + xmu <- nleq(l, u, L) # nonlinear equation solver + x <- xmu[1:(d - 1)] + mu <- xmu[d:(2 * d - 2)] # assign saddlepoint x* and mu* + + fun <- function(n) { + r1 <- .rx$rxMvnrnd(5, L, l, u, mu) + expect_equal(length(r1$logpr), 5) + expect_true(all(!duplicated(r1$logpr))) + expect_equal(length(r1$Z[1, ]), 5) + expect_true(all(!duplicated(r1$Z[1, ]))) + } + fun(2) + fun(5) + fun(10) + }) - Lfull <- out$L - l <- out$l - u <- out$u - D <- diag(Lfull) - perm <- out$perm - if (any(D < 10^-10)) { - warning("Method may fail as covariance matrix is singular!") - } - L <- Lfull / D - u <- u / D - l <- l / D # rescale - L <- L - diag(d) # remove diagonal - # find optimal tilting parameter via non-linear equation solver - xmu <- nleq(l, u, L) # nonlinear equation solver - x <- xmu[1:(d - 1)] - mu <- xmu[d:(2 * d - 2)] # assign saddlepoint x* and mu* - - fun <- function(n) { - r1 <- .rx$rxMvnrnd(5, L, l, u, mu) - expect_equal(length(r1$logpr), 5) - expect_true(all(!duplicated(r1$logpr))) - expect_equal(length(r1$Z[1, ]), 5) - expect_true(all(!duplicated(r1$Z[1, ]))) - } - fun(2) - fun(5) - fun(10) }) - }) diff --git a/tests/testthat/test-cmt-order.R b/tests/testthat/test-cmt-order.R index 96a74d2bd..202151830 100644 --- a/tests/testthat/test-cmt-order.R +++ b/tests/testthat/test-cmt-order.R @@ -2,6 +2,7 @@ rxTest({ warfarin <- nlmixr2data::warfarin test_that("cmt() syntax makes sense", { + mod <- rxode2({ a <- 6 b <- 0.6 @@ -26,8 +27,8 @@ rxTest({ a <- 6 b <- 0.6 cmt(matt) # cmt = 1 now - d / dt(intestine) <- -a * intestine - d / dt(blood) <- a * intestine - b * blood + d/dt(intestine) <- -a * intestine + d/dt(blood) <- a * intestine - b * blood }))), regexp = "compartment 'matt' needs differential equations defined" ) @@ -553,4 +554,128 @@ rxTest({ expect_equal(tmp$stateExtra, "cp") }) + test_that("compartment ordering does not affect c-code generation #785", + { + + f1 <- function() { + ini({ + TVCL <- c(0, 0.0308628127403366) + TVV1 <- c(0, 0.132584062223269) + TVQ <- c(0, 0.0107718034646091) + TVV2 <- c(0, 0.0613517707801907) + TVR0 <- c(0, 3.94111989610973) + TVKON <- c(0, 1.31095109796496) + TVKOFF <- c(0, 0.0758072298659602) + TVKDEG <- c(0, 1.07290072658165) + TVKINT <- c(0, 3.49422759360926) + ADD.ERR.PK <- c(0, 0.446231462752061) + ETA.CL ~ 0.0499998244205031 + }) + model({ + CL <- TVCL * exp(ETA.CL) + V1 <- TVV1 + Q <- TVQ + V2 <- TVV2 + R0 <- TVR0 + KON <- TVKON + KOFF <- TVKOFF + KDEG <- TVKDEG + KINT <- TVKINT + KEL <- CL/V1 + K12 <- Q/V1 + K21 <- Q/V2 + KD <- KOFF/KON + KSYN <- R0 * KDEG + A3(0) <- R0 + KEL <- 0 + d/dt(A1) = -(K12 + KEL) * A1 + K21 * A2 - KON * A1 * + A3 + KOFF * A4 * V1 + d/dt(A2) = K12 * A1 - K21 * A2 + d/dt(A3) = KSYN - KDEG * A3 - KON * (A1/V1) * A3 + KOFF * + A4 + d/dt(A4) = KON * (A1/V1) * A3 - (KINT + KOFF) * A4 + CFREE = A1/V1 + CTOT = CFREE + A4 + CP = log(CTOT) + CP ~ add(ADD.ERR.PK) + SPEC.OUT <- SPEC + DGRP.OUT <- DGRP + BW.OUT <- BW + }) + } + + f1 <- f1 %>% zeroRe("omega") + + f2 <- function() { + ini({ + TVCL <- c(0, 0.0308628127403366) + TVV1 <- c(0, 0.132584062223269) + TVQ <- c(0, 0.0107718034646091) + TVV2 <- c(0, 0.0613517707801907) + TVR0 <- c(0, 3.94111989610973) + TVKON <- c(0, 1.31095109796496) + TVKOFF <- c(0, 0.0758072298659602) + TVKDEG <- c(0, 1.07290072658165) + TVKINT <- c(0, 3.49422759360926) + ADD.ERR.PK <- c(0, 0.446231462752061) + ETA.CL ~ 0.0499998244205031 + }) + model({ + cmt(A1) + cmt(A2) + cmt(A3) + cmt(A4) + CL <- TVCL * exp(ETA.CL) + V1 <- TVV1 + Q <- TVQ + V2 <- TVV2 + R0 <- TVR0 + KON <- TVKON + KOFF <- TVKOFF + KDEG <- TVKDEG + KINT <- TVKINT + KEL <- CL/V1 + K12 <- Q/V1 + K21 <- Q/V2 + KD <- KOFF/KON + KSYN <- R0 * KDEG + A3(0) <- R0 + KEL <- 0 + d/dt(A1) = -(K12 + KEL) * A1 + K21 * A2 - KON * A1 * + A3 + KOFF * A4 * V1 + d/dt(A2) = K12 * A1 - K21 * A2 + d/dt(A3) = KSYN - KDEG * A3 - KON * (A1/V1) * A3 + KOFF * + A4 + d/dt(A4) = KON * (A1/V1) * A3 - (KINT + KOFF) * A4 + CFREE = A1/V1 + CTOT = CFREE + A4 + CP = log(CTOT) + CP ~ add(ADD.ERR.PK) + SPEC.OUT <- SPEC + DGRP.OUT <- DGRP + BW.OUT <- BW + }) + } + + f2 <- f2 %>% zeroRe("omega") + + ev <- eventTable() + mybw <- 70 + mymw <- 150000 + mydgrp <- 50 + ev$add.dosing(dose=mydgrp*mybw*1000000/mymw ,nbr.doses= 13, dosing.interval= 7) + ev$add.sampling(seq(0,13*7,length.out=7)) + + ev2 <- ev %>% as.data.frame() %>% + dplyr::mutate(BW=mybw, DGRP=mydgrp, SPEC=4) + + s2 <- rxSolve(f2, ev2, returnType="data.frame") + + s1 <- rxSolve(f1, ev2, returnType="data.frame") + + expect_equal(s1[,c("A1", "A2", "A3", "A4")], + s2[,c("A1", "A2", "A3", "A4")]) + + }) + }) diff --git a/tests/testthat/test-convertId.R b/tests/testthat/test-convertId.R index bd1e07c7e..65179a4ab 100644 --- a/tests/testthat/test-convertId.R +++ b/tests/testthat/test-convertId.R @@ -31,6 +31,7 @@ rxTest({ ) f <- rxSolve(f, dMod) + expect_error(print(f), NA) }) diff --git a/tests/testthat/test-derived.R b/tests/testthat/test-derived.R index c5d36e33f..918389292 100644 --- a/tests/testthat/test-derived.R +++ b/tests/testthat/test-derived.R @@ -1,21 +1,61 @@ -test_that("v1 rate constants", { +rxTest({ + test_that("v1 rate constants", { - p1 <- rxDerived(v1 = 8, k = 0.5, digits = 3) - expect_equal( - p1, - structure(list( + p1 <- rxDerived(v1 = 8, k = 0.5, digits = 3) + expect_equal( + p1, + structure(list( + vc = 8, kel = 0.5, vss = 8, cl = 4, t12alpha = 1.39, + alpha = 0.5, A = 0.125, fracA = 1 + ), + class = "data.frame", row.names = c(NA, -1L) + ) + ) + + p1 <- rxDerived(v1 = 5, k = 0.7, k12 = 0.5, k21 = 0.05, digits = 3) + + expect_equal( + p1, + structure(list( + vc = 5, kel = 0.7, k12 = 0.5, k21 = 0.05, vp = 50, + vss = 55, cl = 3.5, q = 2.5, t12alpha = 0.568, t12beta = 24.2, + alpha = 1.22, beta = 0.0287, A = 0.196, B = 0.00358, fracA = 0.982, + fracB = 0.0179 + ), + class = "data.frame", + row.names = c(NA, -1L) + ) + ) + + p1 <- rxDerived(v1 = 10, k = 0.3, k12 = 0.2, k13 = 0.1, k21 = 0.02, k31 = 0.001, digits = 3) + + expect_equal(p1, structure(list( + vc = 10, kel = 0.3, k12 = 0.2, k21 = 0.02, k13 = 0.1, + k31 = 0.001, vp = 100, vp2 = 1000, vss = 1110, cl = 3, q = 2, + q2 = 1, t12alpha = 1.14, t12beta = 52.2, t12gamma = 931, + alpha = 0.607, beta = 0.0133, gamma = 0.000745, A = 0.0988, + B = 0.00111, C = 6.47e-05, fracA = 0.988, fracB = 0.0111, + fracC = 0.000647 + ), + class = "data.frame", + row.names = c(NA, -1L) + )) + }) + + test_that("Volumes and clearances", { + p1 <- rxDerived(v1 = 8.0, cl = 4.0, digits = 3) + + expect_equal(p1, structure(list( vc = 8, kel = 0.5, vss = 8, cl = 4, t12alpha = 1.39, alpha = 0.5, A = 0.125, fracA = 1 ), - class = "data.frame", row.names = c(NA, -1L) - ) - ) + class = "data.frame", + row.names = c(NA, -1L) + )) - p1 <- rxDerived(v1 = 5, k = 0.7, k12 = 0.5, k21 = 0.05, digits = 3) + p1 <- rxDerived(v1 = 5.0, v2 = 50, cl = 3.5, q = 2.5, digits = 3) - expect_equal( - p1, - structure(list( + expect_equal(p1, structure(list( vc = 5, kel = 0.7, k12 = 0.5, k21 = 0.05, vp = 50, vss = 55, cl = 3.5, q = 2.5, t12alpha = 0.568, t12beta = 24.2, alpha = 1.22, beta = 0.0287, A = 0.196, B = 0.00358, fracA = 0.982, @@ -23,61 +63,23 @@ test_that("v1 rate constants", { ), class = "data.frame", row.names = c(NA, -1L) - ) - ) - - p1 <- rxDerived(v1 = 10, k = 0.3, k12 = 0.2, k13 = 0.1, k21 = 0.02, k31 = 0.001, digits = 3) - - expect_equal(p1, structure(list( - vc = 10, kel = 0.3, k12 = 0.2, k21 = 0.02, k13 = 0.1, - k31 = 0.001, vp = 100, vp2 = 1000, vss = 1110, cl = 3, q = 2, - q2 = 1, t12alpha = 1.14, t12beta = 52.2, t12gamma = 931, - alpha = 0.607, beta = 0.0133, gamma = 0.000745, A = 0.0988, - B = 0.00111, C = 6.47e-05, fracA = 0.988, fracB = 0.0111, - fracC = 0.000647 - ), - class = "data.frame", - row.names = c(NA, -1L) - )) -}) - -test_that("Volumes and clearances", { - p1 <- rxDerived(v1 = 8.0, cl = 4.0, digits = 3) - - expect_equal(p1, structure(list( - vc = 8, kel = 0.5, vss = 8, cl = 4, t12alpha = 1.39, - alpha = 0.5, A = 0.125, fracA = 1 - ), - class = "data.frame", - row.names = c(NA, -1L) - )) + )) - p1 <- rxDerived(v1 = 5.0, v2 = 50, cl = 3.5, q = 2.5, digits = 3) - - expect_equal(p1, structure(list( - vc = 5, kel = 0.7, k12 = 0.5, k21 = 0.05, vp = 50, - vss = 55, cl = 3.5, q = 2.5, t12alpha = 0.568, t12beta = 24.2, - alpha = 1.22, beta = 0.0287, A = 0.196, B = 0.00358, fracA = 0.982, - fracB = 0.0179 - ), - class = "data.frame", - row.names = c(NA, -1L) - )) - - p1 <- rxDerived( - v1 = 10, v2 = 100, v3 = 1000, - cl = 3, q = 2, q2 = 1, digits = 3 - ) + p1 <- rxDerived( + v1 = 10, v2 = 100, v3 = 1000, + cl = 3, q = 2, q2 = 1, digits = 3 + ) - expect_equal(p1, structure(list( - vc = 10, kel = 0.3, k12 = 0.2, k21 = 0.02, k13 = 0.1, - k31 = 0.001, vp = 100, vp2 = 1000, vss = 1110, cl = 3, q = 2, - q2 = 1, t12alpha = 1.14, t12beta = 52.2, t12gamma = 931, - alpha = 0.607, beta = 0.0133, gamma = 0.000745, A = 0.0988, - B = 0.00111, C = 6.47e-05, fracA = 0.988, fracB = 0.0111, - fracC = 0.000647 - ), - class = "data.frame", - row.names = c(NA, -1L) - )) + expect_equal(p1, structure(list( + vc = 10, kel = 0.3, k12 = 0.2, k21 = 0.02, k13 = 0.1, + k31 = 0.001, vp = 100, vp2 = 1000, vss = 1110, cl = 3, q = 2, + q2 = 1, t12alpha = 1.14, t12beta = 52.2, t12gamma = 931, + alpha = 0.607, beta = 0.0133, gamma = 0.000745, A = 0.0988, + B = 0.00111, C = 6.47e-05, fracA = 0.988, fracB = 0.0111, + fracC = 0.000647 + ), + class = "data.frame", + row.names = c(NA, -1L) + )) + }) }) diff --git a/tests/testthat/test-dfRep.R b/tests/testthat/test-dfRep.R index db9eeb9ed..2cd44c1d2 100644 --- a/tests/testthat/test-dfRep.R +++ b/tests/testthat/test-dfRep.R @@ -1,56 +1,58 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("tests the internal df repetition routines", { - expect_equal( - .vecDf(c(a = 1, b = 1, c = 3), 3), - structure(list( - a = c(1, 1, 1), - b = c(1, 1, 1), - c = c(3, 3, 3) - ), - row.names = c(NA, -3L), - class = "data.frame" +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("tests the internal df repetition routines", { + expect_equal( + .vecDf(c(a = 1, b = 1, c = 3), 3), + structure(list( + a = c(1, 1, 1), + b = c(1, 1, 1), + c = c(3, 3, 3) + ), + row.names = c(NA, -3L), + class = "data.frame" + ) ) - ) - expect_error(.vecDf(c(a = 1, b = 1, c = 3), 0)) + expect_error(.vecDf(c(a = 1, b = 1, c = 3), 0)) - d <- 4 + d <- 4 - rxWithSeed( - 42, - matL <- lapply(1:4, function(...) { - tmp <- matrix(rnorm(d^2), d, d) - tcrossprod(tmp, tmp) - }) - ) + rxWithSeed( + 42, + matL <- lapply(1:4, function(...) { + tmp <- matrix(rnorm(d^2), d, d) + tcrossprod(tmp, tmp) + }) + ) - theta <- data.frame( - a = as.double(1:4), b = as.double(5:8), - c = as.double(9:12) - ) + theta <- data.frame( + a = as.double(1:4), b = as.double(5:8), + c = as.double(9:12) + ) - omega <- rxRmvn(4, setNames(1:d, paste0("a", 1:d)), matL) + omega <- rxRmvn(4, setNames(1:d, paste0("a", 1:d)), matL) - expand <- .cbindOme(theta, omega, 4) + expand <- .cbindOme(theta, omega, 4) - expect_equal(expand$a, rep(theta$a, each = 4)) - expect_equal(expand$b, rep(theta$b, each = 4)) - expect_equal(expand$c, rep(theta$c, each = 4)) + expect_equal(expand$a, rep(theta$a, each = 4)) + expect_equal(expand$b, rep(theta$b, each = 4)) + expect_equal(expand$c, rep(theta$c, each = 4)) - expect_equal(expand$a1, omega[, "a1"]) - expect_equal(expand$a2, omega[, "a2"]) - expect_equal(expand$a3, omega[, "a3"]) - expect_equal(expand$a4, omega[, "a4"]) + expect_equal(expand$a1, omega[, "a1"]) + expect_equal(expand$a2, omega[, "a2"]) + expect_equal(expand$a3, omega[, "a3"]) + expect_equal(expand$a4, omega[, "a4"]) - expand2 <- .cbindOme(theta, NULL, 4) + expand2 <- .cbindOme(theta, NULL, 4) - expect_equal(expand2$a, expand$a) - expect_equal(expand2$b, expand$b) - expect_equal(expand2$c, expand$c) + expect_equal(expand2$a, expand$a) + expect_equal(expand2$b, expand$b) + expect_equal(expand2$c, expand$c) - expand3 <- .cbindOme(NULL, omega, 4) + expand3 <- .cbindOme(NULL, omega, 4) - expect_equal(expand3$a1, expand$a1) - expect_equal(expand3$b1, expand$b1) - expect_equal(expand3$c1, expand$c1) - }) -} + expect_equal(expand3$a1, expand$a1) + expect_equal(expand3$b1, expand$b1) + expect_equal(expand3$c1, expand$c1) + }) + } +}) diff --git a/tests/testthat/test-et.R b/tests/testthat/test-et.R index 4c638af8c..9ad735f1b 100644 --- a/tests/testthat/test-et.R +++ b/tests/testthat/test-et.R @@ -1,829 +1,831 @@ -test_that("et import rate=-2", { +rxTest({ + test_that("et import rate=-2", { - d <- data.frame(id = c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), - time = c(0, 2, 12.5, 24.5, 37, 48, 60.5, 72.5, 85.3, 96.5, 108.5, 112.5), - amt = c(25, 0, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 0), - rate = c(-2, 0, -2, -2, -2, -2, -2, -2, -2, -2, -2, 0)) - d2 <- as.data.frame(et(d)) - expect_equal(d2$rate, c(-2, NA_real_, -2, -2, -2, -2, -2, -2, -2, -2, -2, NA_real_)) + d <- data.frame(id = c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), + time = c(0, 2, 12.5, 24.5, 37, 48, 60.5, 72.5, 85.3, 96.5, 108.5, 112.5), + amt = c(25, 0, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 3.5, 0), + rate = c(-2, 0, -2, -2, -2, -2, -2, -2, -2, -2, -2, 0)) + d2 <- as.data.frame(et(d)) + expect_equal(d2$rate, c(-2, NA_real_, -2, -2, -2, -2, -2, -2, -2, -2, -2, NA_real_)) -}) - - -for (radi in c(1, 2)) { - forderForceBase(switch(radi, - TRUE, - FALSE - )) - radix <- switch(radi, - "base::order", - "data.table::forder" - ) - - # context(sprintf("Test event Table et(...) sort:%s", radix)) - et <- et() - - test_that("Empty event table check", { - ## expect_s3_class(et$env,"rxHidden") - expect_equal(et$nobs, 0L) - expect_equal(et$ndose, 0L) - expect_equal(et$get.EventTable(), NULL) - expect_equal(et$get.dosing(), NULL) - expect_equal(et$get.sampling(), NULL) }) - et <- et(1:10) - - test_that("10 sample items", { - expect_equal(et$nobs, 10L) - expect_equal(et$ndose, 0L) - expect_s3_class(et$get.EventTable(), "data.frame") - expect_true(is(et, "rxEt")) - expect_false(et$show["id"]) - expect_false(et$show["cmt"]) - expect_equal(et$get.dosing(), NULL) - expect_equal(length(et$get.sampling()$time), 10) - }) - et <- et(1:10, "matt") - - test_that("compartment check", { - expect_equal(et$nobs, 10L) - expect_equal(et$ndose, 0L) - expect_s3_class(et$get.EventTable(), "data.frame") - expect_true(is(et, "rxEt")) - expect_false(et$show["id"]) - expect_true(et$show["cmt"]) - expect_equal(et$get.dosing(), NULL) - expect_equal(length(et$get.sampling()$time), 10) - }) + for (radi in c(1, 2)) { + forderForceBase(switch(radi, + TRUE, + FALSE + )) + radix <- switch(radi, + "base::order", + "data.table::forder" + ) - et <- et(1:10, cmt = 1) - test_that("compartment check", { - expect_equal(et$nobs, 10L) - expect_equal(et$ndose, 0L) - expect_s3_class(et$get.EventTable(), "data.frame") - expect_true(is(et, "rxEt")) - expect_false(et$show["id"]) - expect_true(et$show["cmt"]) - expect_equal(et$get.dosing(), NULL) - expect_equal(length(et$get.sampling()$time), 10) - expect_true(all(et$cmt == 1L)) - }) + # context(sprintf("Test event Table et(...) sort:%s", radix)) + et <- et() + test_that("Empty event table check", { + ## expect_s3_class(et$env,"rxHidden") + expect_equal(et$nobs, 0L) + expect_equal(et$ndose, 0L) + expect_equal(et$get.EventTable(), NULL) + expect_equal(et$get.dosing(), NULL) + expect_equal(et$get.sampling(), NULL) + }) + et <- et(1:10) + + test_that("10 sample items", { + expect_equal(et$nobs, 10L) + expect_equal(et$ndose, 0L) + expect_s3_class(et$get.EventTable(), "data.frame") + expect_true(is(et, "rxEt")) + expect_false(et$show["id"]) + expect_false(et$show["cmt"]) + expect_equal(et$get.dosing(), NULL) + expect_equal(length(et$get.sampling()$time), 10) + }) - et1 <- et(1:10, id = 1:10) + et <- et(1:10, "matt") + + test_that("compartment check", { + expect_equal(et$nobs, 10L) + expect_equal(et$ndose, 0L) + expect_s3_class(et$get.EventTable(), "data.frame") + expect_true(is(et, "rxEt")) + expect_false(et$show["id"]) + expect_true(et$show["cmt"]) + expect_equal(et$get.dosing(), NULL) + expect_equal(length(et$get.sampling()$time), 10) + }) - test_that("Observation only table check", { - expect_equal(et1$nobs, 100L) - expect_equal(et1$ndose, 0L) - expect_s3_class(et1$get.EventTable(), "data.frame") - expect_true(is(et1, "rxEt")) - expect_true(et1$show["id"]) - expect_false(et1$show["cmt"]) - expect_equal(et1$get.dosing(), NULL) - expect_equal(length(et1$get.sampling()$time), 100) - }) + et <- et(1:10, cmt = 1) + test_that("compartment check", { + expect_equal(et$nobs, 10L) + expect_equal(et$ndose, 0L) + expect_s3_class(et$get.EventTable(), "data.frame") + expect_true(is(et, "rxEt")) + expect_false(et$show["id"]) + expect_true(et$show["cmt"]) + expect_equal(et$get.dosing(), NULL) + expect_equal(length(et$get.sampling()$time), 10) + expect_true(all(et$cmt == 1L)) + }) - ## now resize down - et2 <- et1 %>% et(id = -(2:10)) - - test_that("compartment check", { - expect_equal(et2$nobs, 10L) - expect_equal(et2$ndose, 0L) - expect_s3_class(et2$get.EventTable(), "data.frame") - expect_true(is(et, "rxEt")) - expect_true(et2$show["id"]) - expect_false(et2$show["cmt"]) - expect_equal(et2$get.dosing(), NULL) - expect_equal(length(et2$get.sampling()$time), 10) - }) - ## now resize back up - et3 <- et2 %>% et(id = 1:10) + et1 <- et(1:10, id = 1:10) - test_that("Using simulate with et without windows will warn", { - f1 <- as.data.frame(et3) - f2 <- suppressWarnings({ - as.data.frame(simulate(et3)) + test_that("Observation only table check", { + expect_equal(et1$nobs, 100L) + expect_equal(et1$ndose, 0L) + expect_s3_class(et1$get.EventTable(), "data.frame") + expect_true(is(et1, "rxEt")) + expect_true(et1$show["id"]) + expect_false(et1$show["cmt"]) + expect_equal(et1$get.dosing(), NULL) + expect_equal(length(et1$get.sampling()$time), 100) }) - expect_equal(f1$time, f2$time) - expect_warning(simulate(et3)) - }) - - eti <- et(amt = 10) %>% et(id = 2:3) - eti1 <- et(amt = 10, id = 3:4) - eti2 <- et(amt = 10, id = 3) - - eti3 <- et(10, id = 3:4) - eti4 <- et(10, id = 3) - - eti5 <- et(10) %>% et(id = 2:3) - - eti6 <- et(amt = 10) %>% et(id = 2) - - eti7 <- et(10) %>% et(id = 2) - - - eti8 <- et(10, id = 1) - eti9 <- et(10) %>% et(id = 1) - eti10 <- et(amt = 10, id = 1) - eti11 <- et(amt = 10) %>% et(id = 1) - - ## Now look at windows - - eti12 <- et(list(c(10, 11)), id = 1) - eti13 <- et(list(c(10, 11))) %>% et(id = 1) - - eti14 <- et(list(c(10, 11)), amt = 10, id = 1) - eti15 <- et(list(c(10, 11)), amt = 10) %>% et(id = 1) - - - eti16 <- et(list(c(10, 11)), id = 2) - eti17 <- et(list(c(10, 11))) %>% et(id = 2) - - eti18 <- et(list(c(10, 11)), amt = 10, id = 2) - eti19 <- et(list(c(10, 11)), amt = 10) %>% et(id = 2) - - eti20 <- et(list(c(10, 11)), id = 2:3) - eti21 <- et(list(c(10, 11))) %>% et(id = 2:3) - - eti22 <- et(list(c(10, 11)), amt = 10, id = 2:3) - eti23 <- et(list(c(10, 11)), amt = 10) %>% et(id = 2:3) - - ## Now do it with dosing/sampling windows - - test_that("Make sure that et only has IDs 2 and 3.", { - expect_equal(eti$id, 2:3) - expect_equal(eti1$id, 3:4) - expect_equal(eti2$id, 3) - expect_equal(eti3$id, 3:4) - expect_equal(eti4$id, 3) - expect_equal(eti5$id, 2:3) - expect_equal(eti6$id, 2) - expect_equal(eti7$id, 2) - expect_equal(eti8$id, 1) - expect_true(eti8$env$show["id"]) - expect_equal(eti9$id, 1) - expect_true(eti9$env$show["id"]) - expect_equal(eti10$id, 1) - expect_true(eti10$env$show["id"]) - expect_equal(eti11$id, 1) - expect_true(eti11$env$show["id"]) - expect_equal(eti12$id, 1) - expect_true(eti12$env$show["id"]) - expect_equal(eti13$id, 1) - expect_true(eti13$env$show["id"]) - expect_equal(eti14$id, 1) - expect_true(eti14$env$show["id"]) - expect_equal(eti15$id, 1) - expect_true(eti15$env$show["id"]) - expect_equal(eti16$id, 2) - expect_true(eti16$env$show["id"]) - expect_equal(eti17$id, 2) - expect_true(eti17$env$show["id"]) - expect_equal(eti18$id, 2) - expect_true(eti18$env$show["id"]) - expect_equal(eti19$id, 2) - expect_true(eti19$env$show["id"]) - expect_equal(eti20$id, 2:3) - expect_true(eti20$env$show["id"]) - expect_equal(eti21$id, 2:3) - expect_true(eti21$env$show["id"]) - expect_equal(eti22$id, 2:3) - expect_true(eti22$env$show["id"]) - expect_equal(eti23$id, 2:3) - expect_true(eti23$env$show["id"]) - }) + ## now resize down + et2 <- et1 %>% et(id = -(2:10)) + + test_that("compartment check", { + expect_equal(et2$nobs, 10L) + expect_equal(et2$ndose, 0L) + expect_s3_class(et2$get.EventTable(), "data.frame") + expect_true(is(et, "rxEt")) + expect_true(et2$show["id"]) + expect_false(et2$show["cmt"]) + expect_equal(et2$get.dosing(), NULL) + expect_equal(length(et2$get.sampling()$time), 10) + }) - test_that("Observation only table check", { - expect_equal(et1$nobs, 100L) - expect_equal(et1$ndose, 0L) - expect_s3_class(et1$get.EventTable(), "data.frame") - expect_true(is(et1, "rxEt")) - expect_true(et1$show["id"]) - expect_false(et1$show["cmt"]) - expect_equal(et1$get.dosing(), NULL) - expect_equal(length(et1$get.sampling()$time), 100) - }) - - ## Check adding different units of time, rate, amt work - test_that("units tests", { - skip_if_not_installed("units") - ## Make sure units are right. - et3 <- et3 %>% units::set_units(mg) - e <- et(amount.units = "mg", time_units = "hr") %>% - add.sampling(seq(0, 24, by = 3)) %>% - add.dosing(1, 3) %>% - et(rate = 3, amt = 2, time = 120) - e2 <- e %>% et(amt = units::set_units(0.0003, "lb"), time = 0.5) - expect_equal(e2$amt[e2$time == units::set_units(0.5, hr)], units::set_units(units::set_units(0.0003, lb), mg)) - e2 <- e %>% et(units::set_units(30, min)) - expect_true(any(e2$time == units::set_units(0.5, hr))) - e2 <- e %>% et(time = 0.25, rate = units::set_units(30, ug / min), amt = units::set_units(4, ug)) - tmp <- e2[e2$time == units::set_units(0.25, hr), ] - expect_equal(units::set_units(1.8, mg / h), tmp$rate) - expect_equal(units::set_units(0.004, mg), tmp$amt) - e2 <- e %>% et(time = 0.25, ii = units::set_units(30, min), amt = 4, addl = 4) - expect_equal(e2$ii[e2$time == units::set_units(0.25, hr)], units::set_units(0.5, hr)) - - ## Check importing wrong different ii and time units as well as different rate units work. - e <- et(amount.units = "mg", time_units = "hr") %>% - add.sampling(seq(0, 24, by = 3)) %>% - add.dosing(1, 3) %>% - et(rate = 3, amt = 2, time = 120) - - etDf <- as.data.frame(e) - etDf$rate <- units::set_units(etDf$rate, ug / s) - etDf$ii <- units::set_units(etDf$ii, min) - et <- et() - et$import.EventTable(etDf) + ## now resize back up + et3 <- et2 %>% et(id = 1:10) - expect_equal(et$ii, e$ii) - expect_equal(et$rate, e$rate) - }) + test_that("Using simulate with et without windows will warn", { + f1 <- as.data.frame(et3) + f2 <- suppressWarnings({ + as.data.frame(simulate(et3)) + }) + expect_equal(f1$time, f2$time) + expect_warning(simulate(et3)) + }) - test_that("seq works with wait", { + eti <- et(amt = 10) %>% et(id = 2:3) + eti1 <- et(amt = 10, id = 3:4) + eti2 <- et(amt = 10, id = 3) + + eti3 <- et(10, id = 3:4) + eti4 <- et(10, id = 3) + + eti5 <- et(10) %>% et(id = 2:3) + + eti6 <- et(amt = 10) %>% et(id = 2) + + eti7 <- et(10) %>% et(id = 2) + + + eti8 <- et(10, id = 1) + eti9 <- et(10) %>% et(id = 1) + eti10 <- et(amt = 10, id = 1) + eti11 <- et(amt = 10) %>% et(id = 1) + + ## Now look at windows + + eti12 <- et(list(c(10, 11)), id = 1) + eti13 <- et(list(c(10, 11))) %>% et(id = 1) + + eti14 <- et(list(c(10, 11)), amt = 10, id = 1) + eti15 <- et(list(c(10, 11)), amt = 10) %>% et(id = 1) + + + eti16 <- et(list(c(10, 11)), id = 2) + eti17 <- et(list(c(10, 11))) %>% et(id = 2) + + eti18 <- et(list(c(10, 11)), amt = 10, id = 2) + eti19 <- et(list(c(10, 11)), amt = 10) %>% et(id = 2) + + eti20 <- et(list(c(10, 11)), id = 2:3) + eti21 <- et(list(c(10, 11))) %>% et(id = 2:3) + + eti22 <- et(list(c(10, 11)), amt = 10, id = 2:3) + eti23 <- et(list(c(10, 11)), amt = 10) %>% et(id = 2:3) + + ## Now do it with dosing/sampling windows + + test_that("Make sure that et only has IDs 2 and 3.", { + expect_equal(eti$id, 2:3) + expect_equal(eti1$id, 3:4) + expect_equal(eti2$id, 3) + expect_equal(eti3$id, 3:4) + expect_equal(eti4$id, 3) + expect_equal(eti5$id, 2:3) + expect_equal(eti6$id, 2) + expect_equal(eti7$id, 2) + expect_equal(eti8$id, 1) + expect_true(eti8$env$show["id"]) + expect_equal(eti9$id, 1) + expect_true(eti9$env$show["id"]) + expect_equal(eti10$id, 1) + expect_true(eti10$env$show["id"]) + expect_equal(eti11$id, 1) + expect_true(eti11$env$show["id"]) + expect_equal(eti12$id, 1) + expect_true(eti12$env$show["id"]) + expect_equal(eti13$id, 1) + expect_true(eti13$env$show["id"]) + expect_equal(eti14$id, 1) + expect_true(eti14$env$show["id"]) + expect_equal(eti15$id, 1) + expect_true(eti15$env$show["id"]) + expect_equal(eti16$id, 2) + expect_true(eti16$env$show["id"]) + expect_equal(eti17$id, 2) + expect_true(eti17$env$show["id"]) + expect_equal(eti18$id, 2) + expect_true(eti18$env$show["id"]) + expect_equal(eti19$id, 2) + expect_true(eti19$env$show["id"]) + expect_equal(eti20$id, 2:3) + expect_true(eti20$env$show["id"]) + expect_equal(eti21$id, 2:3) + expect_true(eti21$env$show["id"]) + expect_equal(eti22$id, 2:3) + expect_true(eti22$env$show["id"]) + expect_equal(eti23$id, 2:3) + expect_true(eti23$env$show["id"]) + }) - e1 <- et(amt = 100, ii = 24, addl = 6) - e2 <- et(amt = 200, ii = 24, addl = 6) + test_that("Observation only table check", { + expect_equal(et1$nobs, 100L) + expect_equal(et1$ndose, 0L) + expect_s3_class(et1$get.EventTable(), "data.frame") + expect_true(is(et1, "rxEt")) + expect_true(et1$show["id"]) + expect_false(et1$show["cmt"]) + expect_equal(et1$get.dosing(), NULL) + expect_equal(length(et1$get.sampling()$time), 100) + }) - e3 <- seq(e1, e2, e1) + ## Check adding different units of time, rate, amt work + test_that("units tests", { + skip_if_not_installed("units") + ## Make sure units are right. + et3 <- et3 %>% units::set_units(mg) + e <- et(amount.units = "mg", time_units = "hr") %>% + add.sampling(seq(0, 24, by = 3)) %>% + add.dosing(1, 3) %>% + et(rate = 3, amt = 2, time = 120) + e2 <- e %>% et(amt = units::set_units(0.0003, "lb"), time = 0.5) + expect_equal(e2$amt[e2$time == units::set_units(0.5, hr)], units::set_units(units::set_units(0.0003, lb), mg)) + e2 <- e %>% et(units::set_units(30, min)) + expect_true(any(e2$time == units::set_units(0.5, hr))) + e2 <- e %>% et(time = 0.25, rate = units::set_units(30, ug / min), amt = units::set_units(4, ug)) + tmp <- e2[e2$time == units::set_units(0.25, hr), ] + expect_equal(units::set_units(1.8, mg / h), tmp$rate) + expect_equal(units::set_units(0.004, mg), tmp$amt) + e2 <- e %>% et(time = 0.25, ii = units::set_units(30, min), amt = 4, addl = 4) + expect_equal(e2$ii[e2$time == units::set_units(0.25, hr)], units::set_units(0.5, hr)) + + ## Check importing wrong different ii and time units as well as different rate units work. + e <- et(amount.units = "mg", time_units = "hr") %>% + add.sampling(seq(0, 24, by = 3)) %>% + add.dosing(1, 3) %>% + et(rate = 3, amt = 2, time = 120) + + etDf <- as.data.frame(e) + etDf$rate <- units::set_units(etDf$rate, ug / s) + etDf$ii <- units::set_units(etDf$ii, min) + + et <- et() + et$import.EventTable(etDf) + + expect_equal(et$ii, e$ii) + expect_equal(et$rate, e$rate) + }) - e4 <- seq(e1, wait = 72, e2, wait = 72, e1) %>% as.data.frame() + test_that("seq works with wait", { - expect_equal(structure(list( - time = c(0, 216, 432), - amt = c(100, 200, 100), - ii = c(24, 24, 24), - addl = c(6L, 6L, 6L), - evid = c(1L, 1L, 1L) - ), - class = "data.frame", - row.names = c(NA, -3L) - ), e4) + e1 <- et(amt = 100, ii = 24, addl = 6) - e5 <- etSeq(e1, wait = 72, e2, wait = 72, e1, waitII = "+ii") %>% - as.data.frame() + e2 <- et(amt = 200, ii = 24, addl = 6) - expect_equal(structure(list( - time = c(0, 240, 480), - amt = c(100, 200, 100), - ii = c(24, 24, 24), - addl = c(6L, 6L, 6L), - evid = c(1L, 1L, 1L) - ), - class = "data.frame", - row.names = c(NA, -3L) - ), e5) + e3 <- seq(e1, e2, e1) - e1 <- et(amt = 500) - e2 <- et(amt = 250, ii = 24, addl = 4) + e4 <- seq(e1, wait = 72, e2, wait = 72, e1) %>% as.data.frame() - expect_equal( - structure(list( - time = c(0, 24), - amt = c(500, 250), - ii = c(0, 24), - addl = c(0L, 4L), - evid = c(1L, 1L) + expect_equal(structure(list( + time = c(0, 216, 432), + amt = c(100, 200, 100), + ii = c(24, 24, 24), + addl = c(6L, 6L, 6L), + evid = c(1L, 1L, 1L) ), class = "data.frame", - row.names = c(NA, -2L) - ), - c(e1, e2) %>% as.data.frame() - ) + row.names = c(NA, -3L) + ), e4) - expect_equal( - structure(list( - time = c(0, 120, 144), - amt = c(250, 500, 250), - ii = c(24, 0, 24), - addl = c(4L, 0L, 4L), + e5 <- etSeq(e1, wait = 72, e2, wait = 72, e1, waitII = "+ii") %>% + as.data.frame() + + expect_equal(structure(list( + time = c(0, 240, 480), + amt = c(100, 200, 100), + ii = c(24, 24, 24), + addl = c(6L, 6L, 6L), evid = c(1L, 1L, 1L) ), class = "data.frame", row.names = c(NA, -3L) - ), - c(e2, e1, e2) %>% as.data.frame() - ) - - e3 <- et(amt = 200) + ), e5) + + e1 <- et(amt = 500) + e2 <- et(amt = 250, ii = 24, addl = 4) + + expect_equal( + structure(list( + time = c(0, 24), + amt = c(500, 250), + ii = c(0, 24), + addl = c(0L, 4L), + evid = c(1L, 1L) + ), + class = "data.frame", + row.names = c(NA, -2L) + ), + c(e1, e2) %>% as.data.frame() + ) - expect_warning(c(e1, e3)) + expect_equal( + structure(list( + time = c(0, 120, 144), + amt = c(250, 500, 250), + ii = c(24, 0, 24), + addl = c(4L, 0L, 4L), + evid = c(1L, 1L, 1L) + ), + class = "data.frame", + row.names = c(NA, -3L) + ), + c(e2, e1, e2) %>% as.data.frame() + ) - e4 <- suppressWarnings(c(e1, e3) %>% as.data.frame()) + e3 <- et(amt = 200) - expect_equal( - structure(list( - time = c(0, 24), - amt = c(500, 200), - ii = c(0, 0), - addl = c(0L, 0L), - evid = c(1L, 1L) - ), - class = "data.frame", - row.names = c(NA, -2L) - ), - e4 - ) + expect_warning(c(e1, e3)) - e4 <- suppressWarnings(c(e1, e3, ii = 12) %>% as.data.frame()) - - expect_equal( - structure(list( - time = c(0, 12), - amt = c(500, 200), - ii = c(0, 0), - addl = c(0L, 0L), - evid = c(1L, 1L) - ), - class = "data.frame", - row.names = c(NA, -2L) - ), - e4 - ) + e4 <- suppressWarnings(c(e1, e3) %>% as.data.frame()) + expect_equal( + structure(list( + time = c(0, 24), + amt = c(500, 200), + ii = c(0, 0), + addl = c(0L, 0L), + evid = c(1L, 1L) + ), + class = "data.frame", + row.names = c(NA, -2L) + ), + e4 + ) - e1 <- et(amt = 100, ii = 24, addl = 6) %>% - et(seq(0, 2 * 168, by = 0.1)) - e2 <- c(e1, e1, samples = "use") - expect_equal(range(e2$time), c(0, 672)) + e4 <- suppressWarnings(c(e1, e3, ii = 12) %>% as.data.frame()) + + expect_equal( + structure(list( + time = c(0, 12), + amt = c(500, 200), + ii = c(0, 0), + addl = c(0L, 0L), + evid = c(1L, 1L) + ), + class = "data.frame", + row.names = c(NA, -2L) + ), + e4 + ) - ## combine without changing, use rbind - e1 <- et(amt = 100, ii = 24, addl = 6, ID = 1:5) - e2 <- et(amt = 50, ii = 12, addl = 13, ID = 1:3) - e3 <- et(amt = 200, ii = 24, addl = 2, ID = 1:2) - e4 <- rbind(e1, e2, e3) - expect_equal( - e4 %>% dplyr::select(id, time, amt, ii, addl) %>% as.data.frame(), - structure(list( - id = c(1L, 1L, 1L, 2L, 2L, 2L, 3L, 3L, 4L, 5L), - time = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0), - amt = c(100, 50, 200, 100, 50, 200, 100, 50, 100, 100), - ii = c(24, 12, 24, 24, 12, 24, 24, 12, 24, 24), - addl = c(6L, 13L, 2L, 6L, 13L, 2L, 6L, 13L, 6L, 6L) - ), - class = "data.frame", - row.names = c(NA, -10L) + e1 <- et(amt = 100, ii = 24, addl = 6) %>% + et(seq(0, 2 * 168, by = 0.1)) + e2 <- c(e1, e1, samples = "use") + expect_equal(range(e2$time), c(0, 672)) + + ## combine without changing, use rbind + e1 <- et(amt = 100, ii = 24, addl = 6, ID = 1:5) + e2 <- et(amt = 50, ii = 12, addl = 13, ID = 1:3) + e3 <- et(amt = 200, ii = 24, addl = 2, ID = 1:2) + + e4 <- rbind(e1, e2, e3) + expect_equal( + e4 %>% dplyr::select(id, time, amt, ii, addl) %>% as.data.frame(), + structure(list( + id = c(1L, 1L, 1L, 2L, 2L, 2L, 3L, 3L, 4L, 5L), + time = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0), + amt = c(100, 50, 200, 100, 50, 200, 100, 50, 100, 100), + ii = c(24, 12, 24, 24, 12, 24, 24, 12, 24, 24), + addl = c(6L, 13L, 2L, 6L, 13L, 2L, 6L, 13L, 6L, 6L) + ), + class = "data.frame", + row.names = c(NA, -10L) + ) ) - ) - e4 <- rbind(e1, e2, e3, id = "unique") - expect_equal( - e4 %>% dplyr::select(id, time, amt, ii, addl) %>% as.data.frame(), - structure(list( - id = 1:10, - time = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0), - amt = c(100, 100, 100, 100, 100, 50, 50, 50, 200, 200), - ii = c(24, 24, 24, 24, 24, 12, 12, 12, 24, 24), - addl = c(6L, 6L, 6L, 6L, 6L, 13L, 13L, 13L, 2L, 2L) - ), - class = "data.frame", - row.names = c(NA, -10L) + e4 <- rbind(e1, e2, e3, id = "unique") + expect_equal( + e4 %>% dplyr::select(id, time, amt, ii, addl) %>% as.data.frame(), + structure(list( + id = 1:10, + time = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0), + amt = c(100, 100, 100, 100, 100, 50, 50, 50, 200, 200), + ii = c(24, 24, 24, 24, 24, 12, 12, 12, 24, 24), + addl = c(6L, 6L, 6L, 6L, 6L, 13L, 13L, 13L, 2L, 2L) + ), + class = "data.frame", + row.names = c(NA, -10L) + ) ) - ) - }) + }) - ## FIXME test windows and dur - test_that("no ii throws an error with addl", { - expect_error(et(c(11, 13), amt = 10, addl = 3)) - }) - ## Test Windows - et <- et(list( - c(0, 1), - c(1, 4), - c(4, 8), - c(8, 12), - c(12, 24) - )) %>% - et(amt = 10) %>% - et(c(11, 13), amt = 10, addl = 3, ii = 12) - - test_that("Using simulate with et works and gives a different data frame", { - et2 <- as.data.frame(simulate(et)) - et1 <- as.data.frame(et) - expect_false(all(et1$time == et2$time)) - et3 <- as.data.frame(et) - expect_true(all(et1$time == et3$time)) - et$simulate() - et3 <- as.data.frame(et) - expect_false(all(et1$time == et3$time)) - }) + ## FIXME test windows and dur + test_that("no ii throws an error with addl", { + expect_error(et(c(11, 13), amt = 10, addl = 3)) + }) + ## Test Windows + et <- et(list( + c(0, 1), + c(1, 4), + c(4, 8), + c(8, 12), + c(12, 24) + )) %>% + et(amt = 10) %>% + et(c(11, 13), amt = 10, addl = 3, ii = 12) + + test_that("Using simulate with et works and gives a different data frame", { + et2 <- as.data.frame(simulate(et)) + et1 <- as.data.frame(et) + expect_false(all(et1$time == et2$time)) + et3 <- as.data.frame(et) + expect_true(all(et1$time == et3$time)) + et$simulate() + et3 <- as.data.frame(et) + expect_false(all(et1$time == et3$time)) + }) - test_that("Low/High middle tests; i.e windows", { - et2 <- et[which(!is.na(et$low)), ] - expect_true(et$show["low"]) - expect_true(et$show["high"]) - expect_true(all(et2$time < et2$high)) - expect_true(all(et2$time > et2$low)) - }) + test_that("Low/High middle tests; i.e windows", { + et2 <- et[which(!is.na(et$low)), ] + expect_true(et$show["low"]) + expect_true(et$show["high"]) + expect_true(all(et2$time < et2$high)) + expect_true(all(et2$time > et2$low)) + }) - et <- et(list( - c(0, 1), - c(1, 4), - c(4, 8), - c(8, 12), - c(12, 24) - ), cmt = 1) %>% - et(amt = 10) %>% - et(c(11, 13), amt = 10, addl = 3, ii = 12) - - test_that("Low/High middle tests; i.e windows", { - et2 <- et[which(!is.na(et$low)), ] - expect_true(et$show["low"]) - expect_true(et$show["high"]) - expect_true(all(et2$time < et2$high)) - expect_true(all(et2$time > et2$low)) - }) + et <- et(list( + c(0, 1), + c(1, 4), + c(4, 8), + c(8, 12), + c(12, 24) + ), cmt = 1) %>% + et(amt = 10) %>% + et(c(11, 13), amt = 10, addl = 3, ii = 12) + + test_that("Low/High middle tests; i.e windows", { + et2 <- et[which(!is.na(et$low)), ] + expect_true(et$show["low"]) + expect_true(et$show["high"]) + expect_true(all(et2$time < et2$high)) + expect_true(all(et2$time > et2$low)) + }) - test_that("Window Errors", { - expect_error(et(list(c(1, 0)))) - expect_error(et(list(c(0, 1, 2)))) - }) - test_that("until is inclusive", { - expect_equal(et(amt = 1, time = 50, until = 57.5, ii = 1.5)$addl, 5) - expect_equal(et(amt = 1, time = 50, until = 57.49999, ii = 1.5)$addl, 4) - expect_equal(et(amt = 1, time = 50, until = 57.50001, ii = 1.5)$addl, 5) - }) + test_that("Window Errors", { + expect_error(et(list(c(1, 0)))) + expect_error(et(list(c(0, 1, 2)))) + }) + test_that("until is inclusive", { + expect_equal(et(amt = 1, time = 50, until = 57.5, ii = 1.5)$addl, 5) + expect_equal(et(amt = 1, time = 50, until = 57.49999, ii = 1.5)$addl, 4) + expect_equal(et(amt = 1, time = 50, until = 57.50001, ii = 1.5)$addl, 5) + }) - test_that("et expected errors", { - expect_error(et(list(c(2, 1), c(3, 4)), amt = 3)) - expect_error(et(list(c(1, 2), 3, c(1, 2, 3)), amt = 3)) - expect_error(et(list(c(1, 2), 3, TRUE), amt = 3)) - }) + test_that("et expected errors", { + expect_error(et(list(c(2, 1), c(3, 4)), amt = 3)) + expect_error(et(list(c(1, 2), 3, c(1, 2, 3)), amt = 3)) + expect_error(et(list(c(1, 2), 3, TRUE), amt = 3)) + }) - test_that("et steady state constant infusion", { - expect_error(et(amt = 0, rate = 10, ii = 0, ss = 2)) - expect_error(et(amt = 0, rate = 10, ii = 2, ss = 1)) - expect_error(et(amt = 0, rate = -2, ii = 0, ss = 1)) - expect_error(et(rate = 10, ii = 0, ss = 2)) - expect_error(et(rate = 10, ii = 2, ss = 1)) - expect_error(et(rate = -2, ii = 0, ss = 1)) - - t1 <- et(amt = 0, rate = 10, ii = 0, ss = 1) %>% as.data.frame() - t2 <- et(rate = 10, ii = 0, ss = 1) %>% as.data.frame() - expect_equal(t1, t2) - - t1 <- et(amt = 0, rate = -1, ii = 0, ss = 1) %>% as.data.frame() - t2 <- et(rate = -1, ii = 0, ss = 1) %>% as.data.frame() - expect_equal(t1, t2) - }) + test_that("et steady state constant infusion", { + expect_error(et(amt = 0, rate = 10, ii = 0, ss = 2)) + expect_error(et(amt = 0, rate = 10, ii = 2, ss = 1)) + expect_error(et(amt = 0, rate = -2, ii = 0, ss = 1)) + expect_error(et(rate = 10, ii = 0, ss = 2)) + expect_error(et(rate = 10, ii = 2, ss = 1)) + expect_error(et(rate = -2, ii = 0, ss = 1)) + + t1 <- et(amt = 0, rate = 10, ii = 0, ss = 1) %>% as.data.frame() + t2 <- et(rate = 10, ii = 0, ss = 1) %>% as.data.frame() + expect_equal(t1, t2) + + t1 <- et(amt = 0, rate = -1, ii = 0, ss = 1) %>% as.data.frame() + t2 <- et(rate = -1, ii = 0, ss = 1) %>% as.data.frame() + expect_equal(t1, t2) + }) - test_that("et addl expand", { - ev <- et(amt = 3, ii = 24, until = 120) - tmp <- etExpand(ev) - expect_equal(ev$amt, 3) - expect_equal(tmp$time, c(0, 24, 48, 72, 96, 120)) - ev$expand() - expect_equal(ev$time, c(0, 24, 48, 72, 96, 120)) - }) + test_that("et addl expand", { + ev <- et(amt = 3, ii = 24, until = 120) + tmp <- etExpand(ev) + expect_equal(ev$amt, 3) + expect_equal(tmp$time, c(0, 24, 48, 72, 96, 120)) + ev$expand() + expect_equal(ev$time, c(0, 24, 48, 72, 96, 120)) + }) - ev2 <- et(amt = 3, ii = 24, until = 120) %>% et(amt = 3, rate = 7) + ev2 <- et(amt = 3, ii = 24, until = 120) %>% et(amt = 3, rate = 7) - test_that("data.frame conversion", { - tmp <- data.frame(ev2) - expect_equal(names(tmp), c("time", "amt", "rate", "ii", "addl", "evid")) - expect_false(inherits(tmp$rate, "rxRateDur")) - expect_false(inherits(tmp$evid, "rxEvid")) - }) + test_that("data.frame conversion", { + tmp <- data.frame(ev2) + expect_equal(names(tmp), c("time", "amt", "rate", "ii", "addl", "evid")) + expect_false(inherits(tmp$rate, "rxRateDur")) + expect_false(inherits(tmp$evid, "rxEvid")) + }) - test_that("tibble conversion", { - tmp <- tibble::as_tibble(ev2) - expect_equal(names(tmp), c("time", "amt", "rate", "ii", "addl", "evid")) - expect_false(inherits(tmp$rate, "rxRateDur")) - expect_false(inherits(tmp$evid, "rxEvid")) - }) -} + test_that("tibble conversion", { + tmp <- tibble::as_tibble(ev2) + expect_equal(names(tmp), c("time", "amt", "rate", "ii", "addl", "evid")) + expect_false(inherits(tmp$rate, "rxRateDur")) + expect_false(inherits(tmp$evid, "rxEvid")) + }) + } -test_that("seq() args work; see #97", { - et1 <- et() %>% add.sampling(seq(0, 24, by = 3)) + test_that("seq() args work; see #97", { + et1 <- et() %>% add.sampling(seq(0, 24, by = 3)) - et2 <- et(from = 0, to = 24, by = 3) + et2 <- et(from = 0, to = 24, by = 3) - expect_equal(et1$time, et2$time) -}) + expect_equal(et1$time, et2$time) + }) -test_that("errors", { - expect_error(et(ii = 12, dosing.interval = 14)) - expect_error(et(dose = 4, amt = 3)) - expect_error(et(cmt = 1, dosing.to = 3)) - expect_error(et(cmt = 1, dose.to = 3)) - expect_error(et(cmt = 1, state = 3)) - expect_error(et(amt.units = "mg", dose.units = "mg")) - expect_error(et(time.units = "mg", timeUnits = "mg")) - expect_error(et(time = 4, start.time = 5)) - expect_error(et(nbr.doses = 4, nbrDoses = 5)) - expect_error(et(dur = 4, duration = 5)) -}) + test_that("errors", { + expect_error(et(ii = 12, dosing.interval = 14)) + expect_error(et(dose = 4, amt = 3)) + expect_error(et(cmt = 1, dosing.to = 3)) + expect_error(et(cmt = 1, dose.to = 3)) + expect_error(et(cmt = 1, state = 3)) + expect_error(et(amt.units = "mg", dose.units = "mg")) + expect_error(et(time.units = "mg", timeUnits = "mg")) + expect_error(et(time = 4, start.time = 5)) + expect_error(et(nbr.doses = 4, nbrDoses = 5)) + expect_error(et(dur = 4, duration = 5)) + }) -test_that("dose=0 is OK; see #192", { - ev1 <- et(amt = 0, time = 10) - ev2 <- eventTable() - ev2$add.dosing(dose = 0, start.time = 10) + test_that("dose=0 is OK; see #192", { + ev1 <- et(amt = 0, time = 10) + ev2 <- eventTable() + ev2$add.dosing(dose = 0, start.time = 10) - expect_equal(as.data.frame(ev1), as.data.frame(ev2)) -}) + expect_equal(as.data.frame(ev1), as.data.frame(ev2)) + }) -test_that("Issue #236 math in to/from", { - expect_error(et(from = 0, to = 168 * 2 * 6, length.out = 168 * 2 * 6 + 1), NA) -}) + test_that("Issue #236 math in to/from", { + expect_error(et(from = 0, to = 168 * 2 * 6, length.out = 168 * 2 * 6 + 1), NA) + }) -test_that("Issue #257 numeric cmt vectorized", { - ds4 <- c(1, 2, 3, 4) - rate <- c(1.5, 2.5, 3.5, 4.5) - expect_error(et() %>% et(amt = ds4, rate = rate, cmt = 4), NA) -}) + test_that("Issue #257 numeric cmt vectorized", { + ds4 <- c(1, 2, 3, 4) + rate <- c(1.5, 2.5, 3.5, 4.5) + expect_error(et() %>% et(amt = ds4, rate = rate, cmt = 4), NA) + }) -test_that("etRep #313", { - skip_if_not_installed("units") - sch1 <- et(timeUnits = "hr") %>% - et(amt = 100, ii = 24, until = units::set_units(2, "days")) + test_that("etRep #313", { + skip_if_not_installed("units") + sch1 <- et(timeUnits = "hr") %>% + et(amt = 100, ii = 24, until = units::set_units(2, "days")) - toto <- rep(sch1, times = 10, wait = units::set_units(19, "days")) + toto <- rep(sch1, times = 10, wait = units::set_units(19, "days")) - expect_equal(toto$time, seq(0, by = 504, length.out = 10)) + expect_equal(toto$time, seq(0, by = 504, length.out = 10)) - sch1 <- et(timeUnits = "hr") %>% - et(amt = 100, ii = 24, until = units::set_units(2, "days")) %>% - etExpand() + sch1 <- et(timeUnits = "hr") %>% + et(amt = 100, ii = 24, until = units::set_units(2, "days")) %>% + etExpand() - toto1 <- etExpand(toto) + toto1 <- etExpand(toto) - expect_warning(toto <- rep(sch1, times = 10, wait = units::set_units(19, "days"))) -}) + expect_warning(toto <- rep(sch1, times = 10, wait = units::set_units(19, "days"))) + }) -test_that("'by' and 'length.out'", { - expect_error(et(0, 3, by = 0.5, length.out = 3)) -}) + test_that("'by' and 'length.out'", { + expect_error(et(0, 3, by = 0.5, length.out = 3)) + }) -test_that("'amt' and 'time' have different values", { - expect_error(et(amt = c(1, 2), time = c(1, 3, 4))) -}) + test_that("'amt' and 'time' have different values", { + expect_error(et(amt = c(1, 2), time = c(1, 3, 4))) + }) -test_that("'time' with invalid list", { - expect_error(et(time = list(1, 2, 3))) -}) + test_that("'time' with invalid list", { + expect_error(et(time = list(1, 2, 3))) + }) -test_that("'is' for rxode2 event tables are 'rxEt'", { - ev <- et() - expect_true(is(ev, "rxEt")) -}) + test_that("'is' for rxode2 event tables are 'rxEt'", { + ev <- et() + expect_true(is(ev, "rxEt")) + }) -test_that("can use 'evid=0' with time entries", { - expect_error(et(amt = 10, cmt = 1, time = 0, evid = 1, id = 1) %>% - et(time = c(0, 10, 20), evid = 0), NA) + test_that("can use 'evid=0' with time entries", { + expect_error(et(amt = 10, cmt = 1, time = 0, evid = 1, id = 1) %>% + et(time = c(0, 10, 20), evid = 0), NA) -}) + }) -test_that("extra doses are not added (nlmixr2/rxode2et#2)", { - foo <- et(amt=10, id=1:2) %>% et(time=1, id=2:3) - expect_equal( - foo$id[!is.na(foo$amt)], - 1:2 - ) -}) + test_that("extra doses are not added (nlmixr2/rxode2et#2)", { + foo <- et(amt=10, id=1:2) %>% et(time=1, id=2:3) + expect_equal( + foo$id[!is.na(foo$amt)], + 1:2 + ) + }) -test_that("event table id, (rxode2et#4)", { - expect_error(et(amt = 10, time = 0, evid = 1, id = 1:5) %>% - et(amt = 100, time = 0, evid = 1, id = 6:10) %>% - et(amt = 1000, time = 0, evid = 1, id = 11), NA) + test_that("event table id, (rxode2et#4)", { + expect_error(et(amt = 10, time = 0, evid = 1, id = 1:5) %>% + et(amt = 100, time = 0, evid = 1, id = 6:10) %>% + et(amt = 1000, time = 0, evid = 1, id = 11), NA) -}) + }) -test_that("event table non-zero time", { - expect_warning(et(amt=1.153846, ii=24*7*6, until=24*7*6*2) %>% - et(amt=1.153846, time=24*7*6*(2+8), ii=24*7*8, until=24*7), "until") -}) + test_that("event table non-zero time", { + expect_warning(et(amt=1.153846, ii=24*7*6, until=24*7*6*2) %>% + et(amt=1.153846, time=24*7*6*(2+8), ii=24*7*8, until=24*7), "until") + }) -test_that("event table cmt needs to be evaluated #16", { + test_that("event table cmt needs to be evaluated #16", { - dosing_df <- data.frame( - DOSE = c(0.1, 0.5), - CMT = c("A", "B"), - TIME = c(0, 0) - ) + dosing_df <- data.frame( + DOSE = c(0.1, 0.5), + CMT = c("A", "B"), + TIME = c(0, 0) + ) - samp_t <- c(0, 0.1, 0.5, 1, 2) + samp_t <- c(0, 0.1, 0.5, 1, 2) - # The below should work... but does not - sub_df <- dosing_df[1, , drop = T] + # The below should work... but does not + sub_df <- dosing_df[1, , drop = T] - expect_error(et( - amt = sub_df$DOSE, - cmt = sub_df$CMT, - time = sub_df$TIME, - evid = 1, - id = 1:5 - ) %>% - add.sampling(time = samp_t), NA) + expect_error(et( + amt = sub_df$DOSE, + cmt = sub_df$CMT, + time = sub_df$TIME, + evid = 1, + id = 1:5 + ) %>% + add.sampling(time = samp_t), NA) -}) + }) -test_that("toTrialDuration works", { - trialEnd = 2 - ev <- et(data.frame(id = rep(1:2, 3), time = c(13, 14, 13.5, 14.5, 15.3, 16.5))) - res <- toTrialDuration(ev, trialEnd = trialEnd, interval = 0.5) - expect_setequal(res$time, c(13, 13.5, 14, 14.5, 15, 14, 14.5, 15, 15.5, 16)) -}) + test_that("toTrialDuration works", { + trialEnd = 2 + ev <- et(data.frame(id = rep(1:2, 3), time = c(13, 14, 13.5, 14.5, 15.3, 16.5))) + res <- toTrialDuration(ev, trialEnd = trialEnd, interval = 0.5) + expect_setequal(res$time, c(13, 13.5, 14, 14.5, 15, 14, 14.5, 15, 15.5, 16)) + }) -test_that("Ad issue #23", { + test_that("Ad issue #23", { - cmti <- "Ad" - dose_nmol <- 3 - dosing <- et(time = 0, amt = dose_nmol, cmt = cmti) + cmti <- "Ad" + dose_nmol <- 3 + dosing <- et(time = 0, amt = dose_nmol, cmt = cmti) - expect_equal(dosing$cmt, "Ad") + expect_equal(dosing$cmt, "Ad") - dosing <- et(time = 0, amt = dose_nmol, cmt = cmtj) + dosing <- et(time = 0, amt = dose_nmol, cmt = cmtj) - expect_equal(dosing$cmt, "cmtj") + expect_equal(dosing$cmt, "cmtj") -}) + }) -test_that("test import with NA time", { + test_that("test import with NA time", { - e <- et() + e <- et() - expect_warning(e$importEventTable(data.frame( - ID = "A", - TIME = c(738.9333333, NA), - CMT = c("depot", "central"), - AMT = c(300, NA), - EVID = c(1, 0), - DOSE = 300, - COVAR = 1 - ))) + expect_warning(e$importEventTable(data.frame( + ID = "A", + TIME = c(738.9333333, NA), + CMT = c("depot", "central"), + AMT = c(300, NA), + EVID = c(1, 0), + DOSE = 300, + COVAR = 1 + ))) -}) + }) -test_that("another import", { - - e <- et() - - expect_warning(e$importEventTable(data.frame(ID = c("A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", - "A131", "A131", "A131", "A131", "A132", "A132", "A132", "A132", - "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", - "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", - "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", - "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", - "A132", "A132", "A132", "A132", "A133", "A133", "A133", "A133", - "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", - "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", - "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", - "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", - "A133", "A133", "A133", "A134", "A134", "A134", "A134", "A134", - "A134", "A134", "A134", "A134", "A134", "A134", "A135", "A135", - "A135", "A135", "A135", "A135", "A135", "A135", "A135", "A135", - "A135", "A135", "A135", "A135", "A135", "A135", "A135", "A135", - "A135", "A135", "A135", "A135", "A135", "A135", "A135", "A135", - "A135", "A135", "A135", "A135", "A135"), - TIME = c(0, 0, 1.3, - 1.883333333, 2.766666667, 4.85, 6.883333333, 7.816666667, 23.81666667, - 47.81666667, 71.81666667, 95.81666667, 166.2, 166.2, 190.2, 214.2, - 238.2, 262.2, 332.3333333, 332.3333333, 332.95, 333.5333333, - 334.5333333, 336.5333333, 338.5333333, 339.45, 355.45, 379.45, - 403.45, 427.45, 504.3166667, 504.3166667, 528.3166667, 552.3166667, - 576.3166667, 672.3166667, 696.3166667, 720.3166667, 744.3166667, - 840.3166667, 864.3166667, 888.3166667, 909.5333333, 909.5333333, - 910.3666667, 910.8166667, 911.7, 913.45, 915.4, 917, 1009.783333, - 1009.783333, 1012.3, 1034.3, 1058.3, 1082.3, 1178.3, 1202.3, - 1226.3, 1250.3, 2016.1, 2016.1, 2040.1, 2064.1, 2088.1, 2184.1, - 2208.1, 2232.1, 2256.1, 2352.1, 2376.1, 2400.1, 2424.1, 2522.1, - 2522.1, 2522.45, 2544.45, 2568.45, 2592.45, 2688.45, 2712.45, - 2736.45, 2760.45, 2856.45, 2880.45, 2904.45, 2928.45, 3025.8, - 3025.8, 3028.266667, 3050.266667, 3074.266667, 3098.266667, 3194.266667, - 3218.266667, 3242.266667, 3266.266667, 0, 0, 0.85, 24.35, 48.35, - 72.35, 96.35, 336.35, 360.35, 384.35, 408.35, 432.35, 500.7, - 500.7, 503.0166667, 525.0166667, 549.0166667, 573.0166667, 597.0166667, - 666.1333333, 666.1333333, 666.9833333, 667.4833333, 668.4833333, - 669.9833333, 672.0333333, 673.7, 689.7, 713.7, 737.7, 761.7, - 833.7, 881.7, 905.7, 1001.7, 1025.7, 1049.7, 1082.816667, 1082.816667, - 1085.7, 0, 0, 1.616666667, 2.033333333, 2.866666667, 4.866666667, - 6.283333333, 24.28333333, 170.2833333, 170.2833333, 194.2833333, - 218.2833333, 242.2833333, 261.6833333, 333.1666667, 357.1666667, - 381.1666667, 405.1666667, 429.1666667, 505.35, 505.35, 508.3333333, - 530.3333333, 554.3333333, 578.3333333, 595.4, 595.4, 596.9333333, - 666.9333333, 690.9333333, 714.9333333, 738.9333333, NA, NA, NA, - NA, NA, NA, NA, 0, 0, 1.133333333, 1.716666667, 2.633333333, - 4.416666667, 6.216666667, 24.21666667, 48.21666667, 72.21666667, - 96.21666667, 0, 0, 0.9666666667, 1.466666667, 2.266666667, 4.35, - 6.016666667, 24.01666667, 48.01666667, 168.0166667, 192.0166667, - 216.0166667, 240.0166667, 264.0166667, 336.0166667, 360.0166667, - 384.0166667, 408.0166667, 432.0166667, 503.3, 503.3, 505.9, 527.9, - 551.9, 575.9, 599.9, 1175.566667, 1175.566667, 1178, 1200, 1224 - ), - CMT = c("central", "depot", "central", "central", "central", - "central", "central", "central", "depot", "depot", "depot", "depot", - "central", "depot", "depot", "depot", "depot", "depot", "central", - "depot", "central", "central", "central", "central", "central", - "central", "depot", "depot", "depot", "depot", "central", "depot", - "depot", "depot", "depot", "depot", "depot", "depot", "depot", - "depot", "depot", "depot", "central", "depot", "central", "central", - "central", "central", "central", "central", "central", "depot", - "central", "depot", "depot", "depot", "depot", "depot", "depot", - "depot", "central", "depot", "depot", "depot", "depot", "depot", - "depot", "depot", "depot", "depot", "depot", "depot", "depot", - "central", "depot", "central", "depot", "depot", "depot", "depot", - "depot", "depot", "depot", "depot", "depot", "depot", "depot", - "central", "depot", "central", "depot", "depot", "depot", "depot", - "depot", "depot", "depot", "central", "depot", "central", "depot", - "depot", "depot", "depot", "depot", "depot", "depot", "depot", - "depot", "central", "depot", "central", "depot", "depot", "depot", - "depot", "central", "depot", "central", "central", "central", - "central", "central", "central", "depot", "depot", "depot", "depot", - "depot", "depot", "depot", "depot", "depot", "depot", "central", - "depot", "central", "central", "depot", "central", "central", - "central", "central", "central", "depot", "central", "depot", - "depot", "depot", "depot", "depot", "depot", "depot", "depot", - "depot", "depot", "central", "depot", "central", "depot", "depot", - "depot", "central", "depot", "central", "depot", "depot", "depot", - "depot", "central", "central", "central", "central", "central", - "central", "central", "central", "depot", "central", "central", - "central", "central", "central", "depot", "depot", "depot", "depot", - "central", "depot", "central", "central", "central", "central", - "central", "depot", "depot", "depot", "depot", "depot", "depot", - "depot", "depot", "depot", "depot", "depot", "depot", "central", - "depot", "central", "depot", "depot", "depot", "depot", "central", - "depot", "central", "depot", "depot"), - AMT = c(NA, 400, NA, NA, - NA, NA, NA, NA, 400, 400, 400, 400, NA, 400, 400, 400, 400, 400, - NA, 400, NA, NA, NA, NA, NA, NA, 400, 400, 400, 400, NA, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, NA, 400, NA, - NA, NA, NA, NA, NA, NA, 400, NA, 400, 400, 400, 400, 400, 400, - 400, NA, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, NA, 400, NA, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, NA, 400, NA, 400, 400, 400, 400, 400, 400, 400, NA, - 500, NA, 500, 500, 500, 500, 450, 450, 450, 450, 450, NA, 450, - NA, 450, 450, 450, 450, NA, 450, NA, NA, NA, NA, NA, NA, 450, - 450, 450, 450, 450, 450, 450, 450, 450, 450, NA, 450, NA, NA, - 350, NA, NA, NA, NA, NA, 350, NA, 300, 300, 300, 300, 300, 300, - 300, 300, 300, 300, NA, 300, NA, 300, 300, 300, NA, 300, NA, - 300, 300, 300, 300, NA, NA, NA, NA, NA, NA, NA, NA, 350, NA, - NA, NA, NA, NA, 350, 350, 350, 350, NA, 400, NA, NA, NA, NA, - NA, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - NA, 400, NA, 400, 400, 400, 400, NA, 400, NA, 400, 400), - DOSE = c(0, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 0, 500, 500, 500, 500, 500, 500, 450, - 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, - 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, - 450, 450, 450, 450, 450, 450, 0, 350, 350, 350, 350, 350, 350, - 350, 350, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, - 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, - 300, 300, 300, 300, 300, 300, 0, 350, 350, 350, 350, 350, 350, - 350, 350, 350, 350, 0, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, - 400, 400, 400, 400, 400, 400, 400, 400, 400), - EVID = c(0, 1, - 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, - 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, - 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, - 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, - 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, - 1, 0, 1, 0, 1, 1), - COVAR = c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, - 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - ))) + test_that("another import", { + + e <- et() + + expect_warning(e$importEventTable(data.frame(ID = c("A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A131", "A131", "A131", "A131", + "A131", "A131", "A131", "A131", "A132", "A132", "A132", "A132", + "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", + "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", + "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", + "A132", "A132", "A132", "A132", "A132", "A132", "A132", "A132", + "A132", "A132", "A132", "A132", "A133", "A133", "A133", "A133", + "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", + "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", + "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", + "A133", "A133", "A133", "A133", "A133", "A133", "A133", "A133", + "A133", "A133", "A133", "A134", "A134", "A134", "A134", "A134", + "A134", "A134", "A134", "A134", "A134", "A134", "A135", "A135", + "A135", "A135", "A135", "A135", "A135", "A135", "A135", "A135", + "A135", "A135", "A135", "A135", "A135", "A135", "A135", "A135", + "A135", "A135", "A135", "A135", "A135", "A135", "A135", "A135", + "A135", "A135", "A135", "A135", "A135"), + TIME = c(0, 0, 1.3, + 1.883333333, 2.766666667, 4.85, 6.883333333, 7.816666667, 23.81666667, + 47.81666667, 71.81666667, 95.81666667, 166.2, 166.2, 190.2, 214.2, + 238.2, 262.2, 332.3333333, 332.3333333, 332.95, 333.5333333, + 334.5333333, 336.5333333, 338.5333333, 339.45, 355.45, 379.45, + 403.45, 427.45, 504.3166667, 504.3166667, 528.3166667, 552.3166667, + 576.3166667, 672.3166667, 696.3166667, 720.3166667, 744.3166667, + 840.3166667, 864.3166667, 888.3166667, 909.5333333, 909.5333333, + 910.3666667, 910.8166667, 911.7, 913.45, 915.4, 917, 1009.783333, + 1009.783333, 1012.3, 1034.3, 1058.3, 1082.3, 1178.3, 1202.3, + 1226.3, 1250.3, 2016.1, 2016.1, 2040.1, 2064.1, 2088.1, 2184.1, + 2208.1, 2232.1, 2256.1, 2352.1, 2376.1, 2400.1, 2424.1, 2522.1, + 2522.1, 2522.45, 2544.45, 2568.45, 2592.45, 2688.45, 2712.45, + 2736.45, 2760.45, 2856.45, 2880.45, 2904.45, 2928.45, 3025.8, + 3025.8, 3028.266667, 3050.266667, 3074.266667, 3098.266667, 3194.266667, + 3218.266667, 3242.266667, 3266.266667, 0, 0, 0.85, 24.35, 48.35, + 72.35, 96.35, 336.35, 360.35, 384.35, 408.35, 432.35, 500.7, + 500.7, 503.0166667, 525.0166667, 549.0166667, 573.0166667, 597.0166667, + 666.1333333, 666.1333333, 666.9833333, 667.4833333, 668.4833333, + 669.9833333, 672.0333333, 673.7, 689.7, 713.7, 737.7, 761.7, + 833.7, 881.7, 905.7, 1001.7, 1025.7, 1049.7, 1082.816667, 1082.816667, + 1085.7, 0, 0, 1.616666667, 2.033333333, 2.866666667, 4.866666667, + 6.283333333, 24.28333333, 170.2833333, 170.2833333, 194.2833333, + 218.2833333, 242.2833333, 261.6833333, 333.1666667, 357.1666667, + 381.1666667, 405.1666667, 429.1666667, 505.35, 505.35, 508.3333333, + 530.3333333, 554.3333333, 578.3333333, 595.4, 595.4, 596.9333333, + 666.9333333, 690.9333333, 714.9333333, 738.9333333, NA, NA, NA, + NA, NA, NA, NA, 0, 0, 1.133333333, 1.716666667, 2.633333333, + 4.416666667, 6.216666667, 24.21666667, 48.21666667, 72.21666667, + 96.21666667, 0, 0, 0.9666666667, 1.466666667, 2.266666667, 4.35, + 6.016666667, 24.01666667, 48.01666667, 168.0166667, 192.0166667, + 216.0166667, 240.0166667, 264.0166667, 336.0166667, 360.0166667, + 384.0166667, 408.0166667, 432.0166667, 503.3, 503.3, 505.9, 527.9, + 551.9, 575.9, 599.9, 1175.566667, 1175.566667, 1178, 1200, 1224 + ), + CMT = c("central", "depot", "central", "central", "central", + "central", "central", "central", "depot", "depot", "depot", "depot", + "central", "depot", "depot", "depot", "depot", "depot", "central", + "depot", "central", "central", "central", "central", "central", + "central", "depot", "depot", "depot", "depot", "central", "depot", + "depot", "depot", "depot", "depot", "depot", "depot", "depot", + "depot", "depot", "depot", "central", "depot", "central", "central", + "central", "central", "central", "central", "central", "depot", + "central", "depot", "depot", "depot", "depot", "depot", "depot", + "depot", "central", "depot", "depot", "depot", "depot", "depot", + "depot", "depot", "depot", "depot", "depot", "depot", "depot", + "central", "depot", "central", "depot", "depot", "depot", "depot", + "depot", "depot", "depot", "depot", "depot", "depot", "depot", + "central", "depot", "central", "depot", "depot", "depot", "depot", + "depot", "depot", "depot", "central", "depot", "central", "depot", + "depot", "depot", "depot", "depot", "depot", "depot", "depot", + "depot", "central", "depot", "central", "depot", "depot", "depot", + "depot", "central", "depot", "central", "central", "central", + "central", "central", "central", "depot", "depot", "depot", "depot", + "depot", "depot", "depot", "depot", "depot", "depot", "central", + "depot", "central", "central", "depot", "central", "central", + "central", "central", "central", "depot", "central", "depot", + "depot", "depot", "depot", "depot", "depot", "depot", "depot", + "depot", "depot", "central", "depot", "central", "depot", "depot", + "depot", "central", "depot", "central", "depot", "depot", "depot", + "depot", "central", "central", "central", "central", "central", + "central", "central", "central", "depot", "central", "central", + "central", "central", "central", "depot", "depot", "depot", "depot", + "central", "depot", "central", "central", "central", "central", + "central", "depot", "depot", "depot", "depot", "depot", "depot", + "depot", "depot", "depot", "depot", "depot", "depot", "central", + "depot", "central", "depot", "depot", "depot", "depot", "central", + "depot", "central", "depot", "depot"), + AMT = c(NA, 400, NA, NA, + NA, NA, NA, NA, 400, 400, 400, 400, NA, 400, 400, 400, 400, 400, + NA, 400, NA, NA, NA, NA, NA, NA, 400, 400, 400, 400, NA, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, NA, 400, NA, + NA, NA, NA, NA, NA, NA, 400, NA, 400, 400, 400, 400, 400, 400, + 400, NA, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, NA, 400, NA, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, NA, 400, NA, 400, 400, 400, 400, 400, 400, 400, NA, + 500, NA, 500, 500, 500, 500, 450, 450, 450, 450, 450, NA, 450, + NA, 450, 450, 450, 450, NA, 450, NA, NA, NA, NA, NA, NA, 450, + 450, 450, 450, 450, 450, 450, 450, 450, 450, NA, 450, NA, NA, + 350, NA, NA, NA, NA, NA, 350, NA, 300, 300, 300, 300, 300, 300, + 300, 300, 300, 300, NA, 300, NA, 300, 300, 300, NA, 300, NA, + 300, 300, 300, 300, NA, NA, NA, NA, NA, NA, NA, NA, 350, NA, + NA, NA, NA, NA, 350, 350, 350, 350, NA, 400, NA, NA, NA, NA, + NA, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + NA, 400, NA, 400, 400, 400, 400, NA, 400, NA, 400, 400), + DOSE = c(0, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 0, 500, 500, 500, 500, 500, 500, 450, + 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, + 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, + 450, 450, 450, 450, 450, 450, 0, 350, 350, 350, 350, 350, 350, + 350, 350, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, + 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, + 300, 300, 300, 300, 300, 300, 0, 350, 350, 350, 350, 350, 350, + 350, 350, 350, 350, 0, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 400, 400, 400, 400, 400, 400, 400), + EVID = c(0, 1, + 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, + 1, 0, 1, 0, 1, 1), + COVAR = c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, + 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + ))) + }) }) diff --git a/tests/testthat/test-etTrans-780.qs b/tests/testthat/test-etTrans-780.qs new file mode 100644 index 000000000..d7e71ee88 Binary files /dev/null and b/tests/testthat/test-etTrans-780.qs differ diff --git a/tests/testthat/test-etTrans.R b/tests/testthat/test-etTrans.R index 264c558ea..cc34eccc8 100644 --- a/tests/testthat/test-etTrans.R +++ b/tests/testthat/test-etTrans.R @@ -1,5 +1,6 @@ rxTest({ # mostly tested in 'rxode2et' test_that("warfarin model", { + warfarin <- nlmixr2data::warfarin mod <- rxode2({ @@ -62,6 +63,7 @@ rxTest({ # mostly tested in 'rxode2et' expect_equal(as.double((t$sex == "male") * 1), t$sm) expect_equal(as.double((t$sex == "female") * 1), t$sf) + }) test_that("etTrans na time evid=2", { @@ -86,6 +88,7 @@ d/dt(blood) = a*intestine - b*blood skip_on_cran() expect_warning(expect_false(any(is.na(etTrans(et, mod)$TIME)))) + }) .Call(`_rxode2_etTransEvidIsObs`, FALSE) @@ -1376,3 +1379,71 @@ d/dt(blood) = a*intestine - b*blood expect_equal(tmp$II, c(24, 0, 0, 0)) }) }) + + +test_that("warning on translation (#780)", { + + p <- test_path("test-etTrans-780.qs") + skip_if_not(file.exists(p)) + dat <- qs::qread(p) + + m <- rxode2parse(" + param(Kpm_pop, V_pop, k_pop, k12_pop, k21_pop, ka_pop, + km_pop, a1_Cp, b1_Cp, a2_Cm, b2_Cm, omega_Kpm, omega_V, + omega_k, omega_k12, omega_k21, omega_ka, omega_km) + cmt(depot) + cmt(central) + cmt(cmt2) + cmt(cmt3) + Kpm = exp(Kpm_pop + omega_Kpm) + V = exp(V_pop + omega_V) + k = exp(k_pop + omega_k) + k12 = exp(k12_pop + omega_k12) + k21 = exp(k21_pop + omega_k21) + ka = exp(ka_pop + omega_ka) + km = exp(km_pop + omega_km) + d/dt(depot) = -ka * depot + d/dt(central) = -k12 * central + k21 * cmt2 + ka * depot - + k * central - Kpm * central + Cp = central/V + d/dt(cmt2) = +k12 * central - k21 * cmt2 + d/dt(cmt3) = +Kpm * central - km * cmt3 + Cm = cmt3/V + y1_Cp = Cp + if (CMT == 5) { + rx_yj_ ~ 2 + rx_lambda_ ~ 1 + rx_low_ ~ 0 + rx_hi_ ~ 1 + rx_pred_f_ ~ y1_Cp + rx_pred_ ~ rx_pred_f_ + rx_r_ ~ ((a1_Cp) + (rx_pred_f_) * (b1_Cp))^2 + ipredSim = rxTBSi(rx_pred_, rx_lambda_, rx_yj_, rx_low_, + rx_hi_) + sim = rxTBSi(rx_pred_ + sqrt(rx_r_) * rxerr.y1_Cp, + rx_lambda_, rx_yj_, rx_low_, rx_hi_) + } + y2_Cm = Cm + if (CMT == 6) { + rx_yj_ ~ 2 + rx_lambda_ ~ 1 + rx_low_ ~ 0 + rx_hi_ ~ 1 + rx_pred_f_ ~ y2_Cm + rx_pred_ ~ rx_pred_f_ + rx_r_ ~ ((a2_Cm) + (rx_pred_f_) * (b2_Cm))^2 + ipredSim = rxTBSi(rx_pred_, rx_lambda_, rx_yj_, rx_low_, + rx_hi_) + sim = rxTBSi(rx_pred_ + sqrt(rx_r_) * rxerr.y2_Cm, + rx_lambda_, rx_yj_, rx_low_, rx_hi_) + } + iwres = (DV - rx_pred_)/sqrt(rx_r_) + ires = DV - rx_pred_ + cmt(y1_Cp) + cmt(y2_Cm) + dvid(5, 6) + ") + + expect_warning(etTrans(dat, m), NA) + +}) diff --git a/tests/testthat/test-example-3-1.R b/tests/testthat/test-example-3-1.R index e6c04884d..1c3e6ea23 100644 --- a/tests/testthat/test-example-3-1.R +++ b/tests/testthat/test-example-3-1.R @@ -1,38 +1,40 @@ -if (!.Call(`_rxode2_isIntel`)) { - ## Example 3.1 from - ## "Solving Differential Equations in R" by Soetaert et al (2012) - ## https://cran.r-project.org/web/packages/diffEq/vignettes/ODEinR.pdf Example #1 - skip_if_not(file.exists(test_path("test-example-3-1.qs"))) - df.test <- qs::qread(test_path("test-example-3-1.qs")) - - ms <- c("liblsoda", "lsoda", "dop853") - ode <- rxode2(model = "d/dt(y) = r * y * (1.0 - y/K);") - .rxWithOptions(list(digits = 6), { - for (meth in ms) { - # context(sprintf("Example 3-1 (%s)", meth)) - - ## create event table with times at which we observe the system - et <- eventTable(time.units = NA) - et$add.sampling(seq(from = 0, to = 20, by = 0.2)) - - ## same model, different initial values (2 and 12) - out1 <- ode$solve(params = c(r = 1, K = 10), events = et, inits = c(y = 2)) - out2 <- ode$solve(params = c(r = 1, K = 10), events = et, inits = c(y = 12)) - - ## matplot(x = out1[,1], y = cbind(out1[,2], out2[,2]), type = "l", - ## main = "logistic growth", xlab="time", ylab="") - - ## Now use a non-stiff solver - out2.ns <- - ode$solve(params = c(r = 1, K = 10), events = et, inits = c(y = 12), method = "dop853") - - df <- round(cbind(out1, out2, out2.ns), 3) - - test_that("Runs example 3.1 correctly", { - expect_equal(df, round(df.test, 3)) - }) - - head(cbind(out1, out2, out2.ns), n = 15) - } - }) -} +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + ## Example 3.1 from + ## "Solving Differential Equations in R" by Soetaert et al (2012) + ## https://cran.r-project.org/web/packages/diffEq/vignettes/ODEinR.pdf Example #1 + skip_if_not(file.exists(test_path("test-example-3-1.qs"))) + df.test <- qs::qread(test_path("test-example-3-1.qs")) + + ms <- c("liblsoda", "lsoda", "dop853") + ode <- rxode2(model = "d/dt(y) = r * y * (1.0 - y/K);") + .rxWithOptions(list(digits = 6), { + for (meth in ms) { + # context(sprintf("Example 3-1 (%s)", meth)) + + ## create event table with times at which we observe the system + et <- eventTable(time.units = NA) + et$add.sampling(seq(from = 0, to = 20, by = 0.2)) + + ## same model, different initial values (2 and 12) + out1 <- ode$solve(params = c(r = 1, K = 10), events = et, inits = c(y = 2)) + out2 <- ode$solve(params = c(r = 1, K = 10), events = et, inits = c(y = 12)) + + ## matplot(x = out1[,1], y = cbind(out1[,2], out2[,2]), type = "l", + ## main = "logistic growth", xlab="time", ylab="") + + ## Now use a non-stiff solver + out2.ns <- + ode$solve(params = c(r = 1, K = 10), events = et, inits = c(y = 12), method = "dop853") + + df <- round(cbind(out1, out2, out2.ns), 3) + + test_that("Runs example 3.1 correctly", { + expect_equal(df, round(df.test, 3)) + }) + + head(cbind(out1, out2, out2.ns), n = 15) + } + }) + } +}) diff --git a/tests/testthat/test-example-3-3.R b/tests/testthat/test-example-3-3.R index ecb3d464d..ef85c1ee5 100644 --- a/tests/testthat/test-example-3-3.R +++ b/tests/testthat/test-example-3-3.R @@ -1,9 +1,10 @@ -if (!.Call(`_rxode2_isIntel`)) { - ## Example 3.3 from - ## "Solving Differential Equations in R" by Soetaert et al (2012) - ## https://cran.r-project.org/web/packages/diffEq/vignettes/ODEinR.pdf Example #3 +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + ## Example 3.3 from + ## "Solving Differential Equations in R" by Soetaert et al (2012) + ## https://cran.r-project.org/web/packages/diffEq/vignettes/ODEinR.pdf Example #3 - rigid.txt <- " + rigid.txt <- " a1 = -2; a2 = 1.25; a3 = -0.5; @@ -11,18 +12,19 @@ d/dt(y1) = a1*y2*y3; d/dt(y2) = a2*y1*y3; d/dt(y3) = a3*y1*y2; " - rigid <- rxode2(rigid.txt) + rigid <- rxode2(rigid.txt) - et <- eventTable() - et$add.sampling(seq(0, 20, by = 0.01)) + et <- eventTable() + et$add.sampling(seq(0, 20, by = 0.01)) - out <- solve(rigid, et, inits = c(y1 = 1, y2 = 0, y3 = 0.9)) + out <- solve(rigid, et, inits = c(y1 = 1, y2 = 0, y3 = 0.9)) - test_that("Test rigid body example", { - expect_equal( - round(as.data.frame(out[c(1:15, seq(2001 - 15, 2001)), ]), 3), - structure(list(time = c(0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 19.85, 19.86, 19.87, 19.88, 19.89, 19.9, 19.91, 19.92, 19.93, 19.94, 19.95, 19.96, 19.97, 19.98, 19.99, 20), y1 = c(1, 1, 1, 0.999, 0.998, 0.997, 0.996, 0.995, 0.994, 0.992, 0.99, 0.988, 0.985, 0.983, 0.98, 0.749, 0.74, 0.731, 0.722, 0.713, 0.704, 0.694, 0.685, 0.675, 0.666, 0.656, 0.646, 0.636, 0.626, 0.616, 0.606), y2 = c(0, 0.011, 0.022, 0.034, 0.045, 0.056, 0.067, 0.079, 0.09, 0.101, 0.112, 0.123, 0.134, 0.145, 0.156, 0.524, 0.532, 0.539, 0.547, 0.554, 0.562, 0.569, 0.576, 0.583, 0.59, 0.597, 0.603, 0.61, 0.616, 0.623, 0.629), y3 = c(0.9, 0.9, 0.9, 0.9, 0.9, 0.899, 0.899, 0.899, 0.898, 0.898, 0.897, 0.897, 0.896, 0.895, 0.895, 0.837, 0.835, 0.833, 0.831, 0.829, 0.827, 0.825, 0.823, 0.821, 0.819, 0.817, 0.815, 0.813, 0.811, 0.809, 0.807)), .Names = c("time", "y1", "y2", "y3"), row.names = c(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L, 11L, 12L, 13L, 14L, 15L, 1986L, 1987L, 1988L, 1989L, 1990L, 1991L, 1992L, 1993L, 1994L, 1995L, 1996L, 1997L, 1998L, 1999L, 2000L, 2001L), class = "data.frame") - ) - }) -} + test_that("Test rigid body example", { + expect_equal( + round(as.data.frame(out[c(1:15, seq(2001 - 15, 2001)), ]), 3), + structure(list(time = c(0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 19.85, 19.86, 19.87, 19.88, 19.89, 19.9, 19.91, 19.92, 19.93, 19.94, 19.95, 19.96, 19.97, 19.98, 19.99, 20), y1 = c(1, 1, 1, 0.999, 0.998, 0.997, 0.996, 0.995, 0.994, 0.992, 0.99, 0.988, 0.985, 0.983, 0.98, 0.749, 0.74, 0.731, 0.722, 0.713, 0.704, 0.694, 0.685, 0.675, 0.666, 0.656, 0.646, 0.636, 0.626, 0.616, 0.606), y2 = c(0, 0.011, 0.022, 0.034, 0.045, 0.056, 0.067, 0.079, 0.09, 0.101, 0.112, 0.123, 0.134, 0.145, 0.156, 0.524, 0.532, 0.539, 0.547, 0.554, 0.562, 0.569, 0.576, 0.583, 0.59, 0.597, 0.603, 0.61, 0.616, 0.623, 0.629), y3 = c(0.9, 0.9, 0.9, 0.9, 0.9, 0.899, 0.899, 0.899, 0.898, 0.898, 0.897, 0.897, 0.896, 0.895, 0.895, 0.837, 0.835, 0.833, 0.831, 0.829, 0.827, 0.825, 0.823, 0.821, 0.819, 0.817, 0.815, 0.813, 0.811, 0.809, 0.807)), .Names = c("time", "y1", "y2", "y3"), row.names = c(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L, 11L, 12L, 13L, 14L, 15L, 1986L, 1987L, 1988L, 1989L, 1990L, 1991L, 1992L, 1993L, 1994L, 1995L, 1996L, 1997L, 1998L, 1999L, 2000L, 2001L), class = "data.frame") + ) + }) + } +}) diff --git a/tests/testthat/test-factorial.R b/tests/testthat/test-factorial.R index 3e9f0ef88..0a3096f1b 100644 --- a/tests/testthat/test-factorial.R +++ b/tests/testthat/test-factorial.R @@ -1,19 +1,21 @@ -if (!.Call(`_rxode2_isIntel`)) { - transTo <- function(model, syntax, match = TRUE) { - mv <- rxModelVars(model) - if (match) { - test_that(sprintf("%s includes %s", model, syntax), { - expect_true(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) - }) - } else { - test_that(sprintf("%s dose not include %s", model, syntax), { - expect_false(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) - }) +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + transTo <- function(model, syntax, match = TRUE) { + mv <- rxModelVars(model) + if (match) { + test_that(sprintf("%s includes %s", model, syntax), { + expect_true(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) + }) + } else { + test_that(sprintf("%s dose not include %s", model, syntax), { + expect_false(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) + }) + } } - } - transTo("d/dt(m)= factorial(1+fac)-cmt*ka", "factorial(1+fac)") - transTo("d/dt(m)= lgamma(1+fac)-cmt*ka", "lgamma(1+fac)") - transTo("d/dt(m)= gamma(1+fac)-cmt*ka", "lgammafn(1+fac)") - transTo("d/dt(m)= lfactorial(1+fac)-cmt*ka", "lgamma1p(1+fac)") -} + transTo("d/dt(m)= factorial(1+fac)-cmt*ka", "factorial(1+fac)") + transTo("d/dt(m)= lgamma(1+fac)-cmt*ka", "lgamma(1+fac)") + transTo("d/dt(m)= gamma(1+fac)-cmt*ka", "lgammafn(1+fac)") + transTo("d/dt(m)= lfactorial(1+fac)-cmt*ka", "lgamma1p(1+fac)") + } +}) diff --git a/tests/testthat/test-geom-amt.R b/tests/testthat/test-geom-amt.R index 04e7ea657..c5b0ca0bf 100644 --- a/tests/testthat/test-geom-amt.R +++ b/tests/testthat/test-geom-amt.R @@ -1,26 +1,28 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that(".amtTrans", { - expect_error( - .amtTrans(data.frame()), - regexp = "need 'amt' aesthetic" - ) - expect_error( - .amtTrans(data.frame(amt = 1)), - regexp = "need 'x' aesthetic" - ) - # No error for missing 'x' if 'time' is present - expect_error( - .amtTrans(data.frame(amt = 1, time = 1)), - regexp = NA - ) - expect_equal( - .amtTrans(data.frame(amt = 1, time = 1)), - data.frame(x = 1, amt = 1, xend = 1, y = -Inf, yend = Inf) - ) - # NA rows are dropped - expect_equal( - .amtTrans(data.frame(amt = c(1, NA), time = 1:2)), - data.frame(x = 1, amt = 1, xend = 1, y = -Inf, yend = Inf) - ) - }) -} +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that(".amtTrans", { + expect_error( + .amtTrans(data.frame()), + regexp = "need 'amt' aesthetic" + ) + expect_error( + .amtTrans(data.frame(amt = 1)), + regexp = "need 'x' aesthetic" + ) + # No error for missing 'x' if 'time' is present + expect_error( + .amtTrans(data.frame(amt = 1, time = 1)), + regexp = NA + ) + expect_equal( + .amtTrans(data.frame(amt = 1, time = 1)), + data.frame(x = 1, amt = 1, xend = 1, y = -Inf, yend = Inf) + ) + # NA rows are dropped + expect_equal( + .amtTrans(data.frame(amt = c(1, NA), time = 1:2)), + data.frame(x = 1, amt = 1, xend = 1, y = -Inf, yend = Inf) + ) + }) + } +}) diff --git a/tests/testthat/test-getindex.R b/tests/testthat/test-getindex.R index af8b50837..fd06b8595 100644 --- a/tests/testthat/test-getindex.R +++ b/tests/testthat/test-getindex.R @@ -1,6 +1,7 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("Index access the right compartment", { - rigid.txt <- " +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("Index access the right compartment", { + rigid.txt <- " y1(0) = 1 y2(0) = 0 y3(0) = 0.9 @@ -11,15 +12,16 @@ d/dt(y1) = a1*y2*y3 d/dt(y2) = a2*y1*y3 d/dt(y3) = a3*y1*y2 " - rigid <- rxode2(rigid.txt) + rigid <- rxode2(rigid.txt) - expect_equal(rxState(rigid, "y1"), 1) - expect_equal(rxState(rigid, "y2"), 2) - expect_equal(rxState(rigid, "y3"), 3) - expect_error(rxState(rigid, "matt"), "cannot locate compartment") - expect_equal(rigid$get.index("y1"), 1) - expect_equal(rigid$get.index("y2"), 2) - expect_equal(rigid$get.index("y3"), 3) - expect_error(rigid$get.index("matt"), "cannot locate compartment") - }) -} + expect_equal(rxState(rigid, "y1"), 1) + expect_equal(rxState(rigid, "y2"), 2) + expect_equal(rxState(rigid, "y3"), 3) + expect_error(rxState(rigid, "matt"), "cannot locate compartment") + expect_equal(rigid$get.index("y1"), 1) + expect_equal(rigid$get.index("y2"), 2) + expect_equal(rigid$get.index("y3"), 3) + expect_error(rigid$get.index("matt"), "cannot locate compartment") + }) + } +}) diff --git a/tests/testthat/test-ignore-state.R b/tests/testthat/test-ignore-state.R index 366ce6af3..780e6e7f1 100644 --- a/tests/testthat/test-ignore-state.R +++ b/tests/testthat/test-ignore-state.R @@ -14,210 +14,149 @@ rxTest({ expect_equal(rxModelVars(mod)$state.ignore, c(0L, 0L)) }) - .rxWithOptions(list(rxode2.syntax.require.ode.first = FALSE), { - mod <- rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) ~ -a * intestine - d / dt(blood) <- a * intestine - b * blood - }) - - mod.f <- rxode2({ - a <- 6 - b <- 0.6 - f(intestine) <- 1 - d / dt(intestine) ~ -a * intestine - d / dt(blood) <- a * intestine - b * blood - }) - - mod.alag <- rxode2({ - a <- 6 - b <- 0.6 - alag(intestine) <- 0 - d / dt(intestine) ~ -a * intestine - d / dt(blood) <- a * intestine - b * blood - }) - - mod.rate <- rxode2({ - a <- 6 - b <- 0.6 - rate(intestine) <- 2 - d / dt(intestine) ~ -a * intestine - d / dt(blood) <- a * intestine - b * blood - }) - - mod.dur <- rxode2({ - a <- 6 - b <- 0.6 - dur(intestine) <- 2 - d / dt(intestine) ~ -a * intestine - d / dt(blood) <- a * intestine - b * blood - }) - - test_that("Ignore first comparment", { - expect_equal(rxModelVars(mod)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.f)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.alag)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.rate)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.dur)$state.ignore, c(1L, 0L)) - }) - - mod <- rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }) - - mod.f <- rxode2({ - a <- 6 - b <- 0.6 - f(blood) <- 1 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }) - - mod.alag <- rxode2({ - a <- 6 - b <- 0.6 - alag(blood) <- 0 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }) - - mod.rate <- rxode2({ - a <- 6 - b <- 0.6 - rate(blood) <- 2 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }) - - mod.dur <- rxode2({ - a <- 6 - b <- 0.6 - dur(blood) <- 2 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }) - - test_that("Nothing ignored", { - expect_equal(rxModelVars(mod)$state.ignore, c(0L, 1L)) - expect_equal(rxModelVars(mod)$state, c("intestine", "blood")) - expect_equal(rxModelVars(mod.f)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.f)$state, c("blood", "intestine")) - expect_equal(rxModelVars(mod.alag)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.alag)$state, c("blood", "intestine")) - expect_equal(rxModelVars(mod.rate)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.rate)$state, c("blood", "intestine")) - expect_equal(rxModelVars(mod.dur)$state.ignore, c(1L, 0L)) - expect_equal(rxModelVars(mod.dur)$state, c("blood", "intestine")) - }) - - mod.f <- rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - f(blood) <- 1 - d / dt(blood) ~ a * intestine - b * blood - }) - - mod.alag <- rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - alag(blood) <- 0 - d / dt(blood) ~ a * intestine - b * blood - }) - - mod.rate <- rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - rate(blood) <- 2 - d / dt(blood) ~ a * intestine - b * blood - }) - - mod.dur <- rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - dur(blood) <- 2 - d / dt(blood) ~ a * intestine - b * blood - }) - - - test_that("Ignore Compartment #2", { - expect_equal(rxModelVars(mod)$state.ignore, c(0L, 1L)) - expect_equal(rxModelVars(mod)$state, c("intestine", "blood")) - expect_equal(rxModelVars(mod.f)$state.ignore, c(0L, 1L)) - expect_equal(rxModelVars(mod.f)$state, c("intestine", "blood")) - expect_equal(rxModelVars(mod.alag)$state.ignore, c(0L, 1L)) - expect_equal(rxModelVars(mod.alag)$state, c("intestine", "blood")) - expect_equal(rxModelVars(mod.rate)$state.ignore, c(0L, 1L)) - expect_equal(rxModelVars(mod.rate)$state, c("intestine", "blood")) - expect_equal(rxModelVars(mod.dur)$state.ignore, c(0L, 1L)) - expect_equal(rxModelVars(mod.dur)$state, c("intestine", "blood")) - }) - }) - - .rxWithOptions(list(rxode2.syntax.require.ode.first = TRUE), { - test_that("errors usually occur", { - suppressMessages(expect_error(rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - alag(blood) <- 0 - d / dt(blood) ~ a * intestine - b * blood - }))) - - suppressMessages(expect_error(rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - rate(blood) <- 2 - d / dt(blood) ~ a * intestine - b * blood - }))) - - suppressMessages(expect_error(rxode2({ - a <- 6 - b <- 0.6 - d / dt(intestine) <- -a * intestine - dur(blood) <- 2 - d / dt(blood) ~ a * intestine - b * blood - }))) - - suppressMessages(expect_error(rxode2({ - a <- 6 - b <- 0.6 - f(blood) <- 1 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }))) - - suppressMessages(expect_error(rxode2({ - a <- 6 - b <- 0.6 - alag(blood) <- 0 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }))) - - suppressMessages(expect_error(rxode2({ - a <- 6 - b <- 0.6 - rate(blood) <- 2 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }))) - - suppressMessages(expect_error(rxode2({ - a <- 6 - b <- 0.6 - dur(blood) <- 2 - d / dt(intestine) <- -a * intestine - d / dt(blood) ~ a * intestine - b * blood - }))) - }) + mod <- rxode2({ + a <- 6 + b <- 0.6 + d / dt(intestine) ~ -a * intestine + d / dt(blood) <- a * intestine - b * blood + }) + + mod.f <- rxode2({ + a <- 6 + b <- 0.6 + f(intestine) <- 1 + d / dt(intestine) ~ -a * intestine + d / dt(blood) <- a * intestine - b * blood + }) + + mod.alag <- rxode2({ + a <- 6 + b <- 0.6 + alag(intestine) <- 0 + d / dt(intestine) ~ -a * intestine + d / dt(blood) <- a * intestine - b * blood + }) + + mod.rate <- rxode2({ + a <- 6 + b <- 0.6 + rate(intestine) <- 2 + d / dt(intestine) ~ -a * intestine + d / dt(blood) <- a * intestine - b * blood + }) + + mod.dur <- rxode2({ + a <- 6 + b <- 0.6 + dur(intestine) <- 2 + d / dt(intestine) ~ -a * intestine + d / dt(blood) <- a * intestine - b * blood + }) + + test_that("Ignore first comparment", { + expect_equal(rxModelVars(mod)$state.ignore, c(1L, 0L)) + expect_equal(rxModelVars(mod.f)$state.ignore, c(1L, 0L)) + expect_equal(rxModelVars(mod.alag)$state.ignore, c(1L, 0L)) + expect_equal(rxModelVars(mod.rate)$state.ignore, c(1L, 0L)) + expect_equal(rxModelVars(mod.dur)$state.ignore, c(1L, 0L)) + }) + + mod <- rxode2({ + a <- 6 + b <- 0.6 + d / dt(intestine) <- -a * intestine + d / dt(blood) ~ a * intestine - b * blood + }) + + mod.f <- rxode2({ + a <- 6 + b <- 0.6 + f(blood) <- 1 + d / dt(intestine) <- -a * intestine + d / dt(blood) ~ a * intestine - b * blood }) + + mod.alag <- rxode2({ + a <- 6 + b <- 0.6 + alag(blood) <- 0 + d / dt(intestine) <- -a * intestine + d / dt(blood) ~ a * intestine - b * blood + }) + + mod.rate <- rxode2({ + a <- 6 + b <- 0.6 + rate(blood) <- 2 + d / dt(intestine) <- -a * intestine + d / dt(blood) ~ a * intestine - b * blood + }) + + mod.dur <- rxode2({ + a <- 6 + b <- 0.6 + dur(blood) <- 2 + d / dt(intestine) <- -a * intestine + d / dt(blood) ~ a * intestine - b * blood + }) + + test_that("Nothing ignored", { + expect_equal(rxModelVars(mod)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.f)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.f)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.alag)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.alag)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.rate)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.rate)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.dur)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.dur)$state, c("intestine", "blood")) + }) + + mod.f <- rxode2({ + a <- 6 + b <- 0.6 + d / dt(intestine) <- -a * intestine + f(blood) <- 1 + d / dt(blood) ~ a * intestine - b * blood + }) + + mod.alag <- rxode2({ + a <- 6 + b <- 0.6 + d / dt(intestine) <- -a * intestine + alag(blood) <- 0 + d / dt(blood) ~ a * intestine - b * blood + }) + + mod.rate <- rxode2({ + a <- 6 + b <- 0.6 + d / dt(intestine) <- -a * intestine + rate(blood) <- 2 + d / dt(blood) ~ a * intestine - b * blood + }) + + mod.dur <- rxode2({ + a <- 6 + b <- 0.6 + d / dt(intestine) <- -a * intestine + dur(blood) <- 2 + d / dt(blood) ~ a * intestine - b * blood + }) + + + test_that("Ignore Compartment #2", { + expect_equal(rxModelVars(mod)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.f)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.f)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.alag)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.alag)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.rate)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.rate)$state, c("intestine", "blood")) + expect_equal(rxModelVars(mod.dur)$state.ignore, c(0L, 1L)) + expect_equal(rxModelVars(mod.dur)$state, c("intestine", "blood")) + }) + }) diff --git a/tests/testthat/test-infusion-bolus.R b/tests/testthat/test-infusion-bolus.R index f8834640d..9aefbe88a 100644 --- a/tests/testthat/test-infusion-bolus.R +++ b/tests/testthat/test-infusion-bolus.R @@ -1,49 +1,51 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("infusion + bolus works correctly", { +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("infusion + bolus works correctly", { - d <- test_path("test-infusion-bolus.qs") - skip_if_not(file.exists(d)) - dataset <- qs::qread(d) + d <- test_path("test-infusion-bolus.qs") + skip_if_not(file.exists(d)) + dataset <- qs::qread(d) - base_model <- function() { - ini({ - POP_CL <- c(0.0, 3.84718, Inf) - POP_VC <- c(0.0, 19.4133, Inf) - POP_QP1 <- c(0.0, 3.84718, 999999.0) - POP_VP1 <- c(0.0, 0.970665, 999999.0) - ETA_1 + ETA_2 + ETA_3 + ETA_4 ~ c(0.145644, 0.0211085, 0.0202481, 0.011449, 0.0042689, 0.09, 0.011449, 0.0042689, 0.009, 0.09) - sigma <- 0.0888837 - }) - model({ - VP1 <- POP_VP1*exp(ETA_4) - QP1 <- POP_QP1*exp(ETA_3) - CL <- POP_CL*exp(ETA_1) - VC <- POP_VC*exp(ETA_2) - V1 <- VC - Q <- QP1 - V2 <- VP1 - d/dt(A_CENTRAL) = Q*A_PERIPHERAL/V2 + (-CL/V1 - Q/V1)*A_CENTRAL - d/dt(A_PERIPHERAL) = -Q*A_PERIPHERAL/V2 + Q*A_CENTRAL/V1 - Fv <- A_CENTRAL - IPRED <- A_CENTRAL/VC - if (IPRED == 0) { - IPREDADJ <- 2.22500000000000E-16 - } else { - IPREDADJ <- IPRED - } - Y <- IPREDADJ - Y ~ prop(sigma) - }) - } + base_model <- function() { + ini({ + POP_CL <- c(0.0, 3.84718, Inf) + POP_VC <- c(0.0, 19.4133, Inf) + POP_QP1 <- c(0.0, 3.84718, 999999.0) + POP_VP1 <- c(0.0, 0.970665, 999999.0) + ETA_1 + ETA_2 + ETA_3 + ETA_4 ~ c(0.145644, 0.0211085, 0.0202481, 0.011449, 0.0042689, 0.09, 0.011449, 0.0042689, 0.009, 0.09) + sigma <- 0.0888837 + }) + model({ + VP1 <- POP_VP1*exp(ETA_4) + QP1 <- POP_QP1*exp(ETA_3) + CL <- POP_CL*exp(ETA_1) + VC <- POP_VC*exp(ETA_2) + V1 <- VC + Q <- QP1 + V2 <- VP1 + d/dt(A_CENTRAL) = Q*A_PERIPHERAL/V2 + (-CL/V1 - Q/V1)*A_CENTRAL + d/dt(A_PERIPHERAL) = -Q*A_PERIPHERAL/V2 + Q*A_CENTRAL/V1 + Fv <- A_CENTRAL + IPRED <- A_CENTRAL/VC + if (IPRED == 0) { + IPREDADJ <- 2.22500000000000E-16 + } else { + IPREDADJ <- IPRED + } + Y <- IPREDADJ + Y ~ prop(sigma) + }) + } - f <- base_model() + f <- base_model() - etTrans(dataset, f$simulationModel) + etTrans(dataset, f$simulationModel) - s <- rxSolve(f, dataset, addDosing = TRUE) - expect_true(any(names(s) == "rate")) - expect_equal(names(s)[2], "resetno") + s <- rxSolve(f, dataset, addDosing = TRUE) + expect_true(any(names(s) == "rate")) + expect_equal(names(s)[2], "resetno") - }) -} + }) + } +}) diff --git a/tests/testthat/test-interp.R b/tests/testthat/test-interp.R index 948d57b88..281f4c5cb 100644 --- a/tests/testthat/test-interp.R +++ b/tests/testthat/test-interp.R @@ -1,31 +1,396 @@ -test_that("interpolation functions", { +rxTest({ + test_that("interpolation functions", { - tmp <- rxModelVars("locf(a);\n ret=a+b") + tmp <- rxModelVars("locf(a);\n ret=a+b") - expect_equal(rxNorm(tmp), "locf(a);\nret=a+b;\n") + expect_equal(rxNorm(tmp), "locf(a);\nret=a+b;\n") - expect_equal(as.character(tmp$interp["a"]), "locf") - expect_equal(as.character(tmp$interp["b"]), "default") + expect_equal(as.character(tmp$interp["a"]), "locf") + expect_equal(as.character(tmp$interp["b"]), "default") - tmp <- rxModelVars("params(b, a);\nlocf(a);\n ret=a+b") + tmp <- rxModelVars("params(b, a);\nlocf(a);\n ret=a+b") - expect_equal(as.character(tmp$interp["a"]), "locf") - expect_equal(as.character(tmp$interp["b"]), "default") + expect_equal(as.character(tmp$interp["a"]), "locf") + expect_equal(as.character(tmp$interp["b"]), "default") - expect_error(rxModelVars("params(b, a);\nlocf(a);\nnocb(a);\n ret=a+b")) + expect_error(rxModelVars("params(b, a);\nlocf(a);\nnocb(a);\n ret=a+b")) - tmp <- rxModelVars("params(b, a);\nlinear(a);\n ret=a+b") + tmp <- rxModelVars("params(b, a);\nlinear(a);\n ret=a+b") - expect_equal(as.character(tmp$interp["a"]), "linear") - expect_equal(as.character(tmp$interp["b"]), "default") + expect_equal(as.character(tmp$interp["a"]), "linear") + expect_equal(as.character(tmp$interp["b"]), "default") - tmp <- rxModelVars("params(b, a);\nnocb(a);\n ret=a+b") - expect_equal(as.character(tmp$interp["a"]), "nocb") - expect_equal(as.character(tmp$interp["b"]), "default") + tmp <- rxModelVars("params(b, a);\nnocb(a);\n ret=a+b") + expect_equal(as.character(tmp$interp["a"]), "nocb") + expect_equal(as.character(tmp$interp["b"]), "default") - tmp <- rxModelVars("params(b, a);\nmidpoint(a);\n ret=a+b") - expect_equal(as.character(tmp$interp["a"]), "midpoint") - expect_equal(as.character(tmp$interp["b"]), "default") + tmp <- rxModelVars("params(b, a);\nmidpoint(a);\n ret=a+b") + expect_equal(as.character(tmp$interp["a"]), "midpoint") + expect_equal(as.character(tmp$interp["b"]), "default") + }) + + test_that("ui $interpLines", { + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + cl.wt <- 0 + v.wt <- 0 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + linear(WT) + locf(b) + nocb(c) + midpoint(d) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl)+ WT ^ 2* cl.wt + v <- exp(tv + eta.v+ WT * v.wt + b + c + d) + linCmt() ~ add(add.sd) + }) + } + + ui <- rxode(f) + + expect_equal(ui$interpLines, + list(str2lang("linear(WT)"), + str2lang("locf(b)"), + str2lang("nocb(c)"), + str2lang("midpoint(d)"))) + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + cl.wt <- 0 + v.wt <- 0 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + linear(WT) + locf(b) + midpoint(d) + nocb(c) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl)+ WT ^ 2* cl.wt + v <- exp(tv + eta.v+ WT * v.wt + b + c + d) + linCmt() ~ add(add.sd) + }) + } + + ui <- rxode(f) + + expect_equal(ui$interpLines, + list(str2lang("linear(WT)"), + str2lang("locf(b)"), + str2lang("nocb(c)"), + str2lang("midpoint(d)"))) + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + cl.wt <- 0 + v.wt <- 0 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + locf(WT, b, d, c) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl)+ WT ^ 2* cl.wt + v <- exp(tv + eta.v+ WT * v.wt + b + c + d) + linCmt() ~ add(add.sd) + }) + } + + ui <- rxode(f) + + expect_equal(ui$interpLines, + list(str2lang("locf(WT, b, d, c)"))) + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + cl.wt <- 0 + v.wt <- 0 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl)+ WT ^ 2* cl.wt + v <- exp(tv + eta.v+ WT * v.wt + b + c + d) + linCmt() ~ add(add.sd) + }) + } + + ui <- rxode(f) + + expect_null(ui$interpLines) + + }) + + + test_that("interp $simulationModel", { + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + cl.wt <- 0 + v.wt <- 0 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + linear(WT) + locf(b) + nocb(c) + midpoint(d) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl)+ WT ^ 2* cl.wt + v <- exp(tv + eta.v+ WT * v.wt + b + c + d) + linCmt() ~ add(add.sd) + }) + } + + ui <- rxode(f) + + expect_error(ui$simulationModel, NA) + + mod <- ui$simulationModel + + expect_true(rxModelVars(mod)$interp["WT"] == "linear") + expect_true(rxModelVars(mod)$interp["b"] == "locf") + expect_true(rxModelVars(mod)$interp["c"] == "nocb") + expect_true(rxModelVars(mod)$interp["d"] == "midpoint") + + expect_error(ui$simulationIniModel, NA) + + mod <- ui$simulationIniModel + + expect_true(rxModelVars(mod)$interp["WT"] == "linear") + expect_true(rxModelVars(mod)$interp["b"] == "locf") + expect_true(rxModelVars(mod)$interp["c"] == "nocb") + expect_true(rxModelVars(mod)$interp["d"] == "midpoint") + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + cl.wt <- 0 + v.wt <- 0 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl)+ WT ^ 2* cl.wt + v <- exp(tv + eta.v+ WT * v.wt + b + c + d) + linCmt() ~ add(add.sd) + }) + } + + ui <- rxode(f) + + + expect_error(ui$simulationModel, NA) + + mod <- ui$simulationModel + + expect_true(rxModelVars(mod)$interp["WT"] == "default") + expect_true(rxModelVars(mod)$interp["b"] == "default") + expect_true(rxModelVars(mod)$interp["c"] == "default") + expect_true(rxModelVars(mod)$interp["d"] == "default") + + expect_error(ui$simulationIniModel, NA) + + mod <- ui$simulationIniModel + + expect_true(rxModelVars(mod)$interp["WT"] == "default") + expect_true(rxModelVars(mod)$interp["b"] == "default") + expect_true(rxModelVars(mod)$interp["c"] == "default") + expect_true(rxModelVars(mod)$interp["d"] == "default") + + + }) + + + test_that("time varying character/factors should not be interpolated by linear solving", { + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + tviov.cl <- c(0, 0.1) + iov.cl1 ~ fix(1) + iov.cl2 ~ fix(1) + add.sd <- 0.7 + }) + model({ + iov.cl <- sqrt(tviov.cl) * ((OCC=="first") * iov.cl1 + + (OCC=="second") * iov.cl2) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } + + + et <- et(amt=100) %>% + et(0:24) %>% + as.data.frame() + + et$OCC <- "first" + et$OCC[et$time > 12] <- "second" + + f <- suppressWarnings(f()$simulationIniModel) + expect_warning(rxSolve(f, et, covsInterpolation="linear")) + expect_warning(rxSolve(f, et, covsInterpolation="nocb"), NA) + expect_warning(rxSolve(f, et, covsInterpolation="locf"), NA) + expect_warning(rxSolve(f, et, covsInterpolation="midpoint")) + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + tviov.cl <- c(0, 0.1) + iov.cl1 ~ fix(1) + iov.cl2 ~ fix(1) + add.sd <- 0.7 + }) + model({ + midpoint(OCC) + iov.cl <- sqrt(tviov.cl) * ((OCC=="first") * iov.cl1 + + (OCC=="second") * iov.cl2) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } + + f <- suppressWarnings(f()$simulationIniModel) + + expect_warning(rxSolve(f, et)) + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + tviov.cl <- c(0, 0.1) + iov.cl1 ~ fix(1) + iov.cl2 ~ fix(1) + add.sd <- 0.7 + }) + model({ + linear(OCC) + iov.cl <- sqrt(tviov.cl) * ((OCC=="first") * iov.cl1 + + (OCC=="second") * iov.cl2) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } + + f <- suppressWarnings(f()$simulationIniModel) + + expect_warning(rxSolve(f, et)) + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + tviov.cl <- c(0, 0.1) + iov.cl1 ~ fix(1) + iov.cl2 ~ fix(1) + add.sd <- 0.7 + }) + model({ + nocb(OCC) + iov.cl <- sqrt(tviov.cl) * ((OCC=="first") * iov.cl1 + + (OCC=="second") * iov.cl2) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } + + f <- suppressWarnings(f()$simulationIniModel) + + expect_warning(rxSolve(f, et), NA) + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + tviov.cl <- c(0, 0.1) + iov.cl1 ~ fix(1) + iov.cl2 ~ fix(1) + add.sd <- 0.7 + }) + model({ + locf(OCC) + iov.cl <- sqrt(tviov.cl) * ((OCC=="first") * iov.cl1 + + (OCC=="second") * iov.cl2) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } + + f <- suppressWarnings(f()$simulationIniModel) + + expect_warning(rxSolve(f, et), NA) + + }) }) diff --git a/tests/testthat/test-keep.R b/tests/testthat/test-keep.R index 0726e6c8f..4b092e83c 100644 --- a/tests/testthat/test-keep.R +++ b/tests/testthat/test-keep.R @@ -1,157 +1,238 @@ -# Individual keep AGE==AGE2 -if (!.Call(`_rxode2_isIntel`)) { - test_that("Make sure the keep gives the right values", { - TVQ <- 4 - TVV3 <- 7 - dat <- data.frame(AGE = c(20, 30), ID = c(10, 20)) %>% - dplyr::mutate(id = seq(from = 1, to = dplyr::n())) %>% - dplyr::rename(NMID = ID) - - - par.tab <- data.frame( - ThetaKa = c(0.7, 0.9), - ThetaCl = c(4.6, 5.4), - ThetaV2 = c(7, 8), - ID = c(10, 20) - ) %>% - dplyr::mutate(id = seq(from = 1, to = dplyr::n())) %>% - dplyr::mutate(ThetaQ = TVQ, ThetaV3 = TVV3) %>% - dplyr::rename(NMID = ID) - - tabtot <- dat %>% - dplyr::left_join(., par.tab, by = c("NMID", "id")) - - mod1 <- rxode2({ - ## PK parameters - CL <- exp(ThetaCl) - KA <- exp(ThetaKa) - V2 <- exp(ThetaV2) - Q <- exp(ThetaQ) - V3 <- exp(ThetaV3) - - K20 <- CL / V2 - K23 <- Q / V2 - K32 <- Q / V3 - - CP <- A2 / V2 - - ## - d / dt(A1) <- -KA * A1 - d / dt(A2) <- KA * transit3 - K23 * A2 + K32 * A3 - K20 * A2 - d / dt(A3) <- K23 * A2 - K32 * A3 - - d / dt(transit1) <- KA * A1 - KA * transit1 - d / dt(transit2) <- KA * transit1 - KA * transit2 - d / dt(transit3) <- KA * transit2 - KA * transit3 - - f(A1) <- 1 - - d / dt(AUC) <- CP - A1(0) <- 0 - A2(0) <- 0 - A3(0) <- 0 - - AGE2 <- AGE +rxTest({ + # Individual keep AGE==AGE2 + if (!.Call(`_rxode2_isIntel`)) { + + test_that("Make sure the keep gives the right values", { + TVQ <- 4 + TVV3 <- 7 + dat <- data.frame(AGE = c(20, 30), ID = c(10, 20)) %>% + dplyr::mutate(id = seq(from = 1, to = dplyr::n())) %>% + dplyr::rename(NMID = ID) + + + par.tab <- data.frame( + ThetaKa = c(0.7, 0.9), + ThetaCl = c(4.6, 5.4), + ThetaV2 = c(7, 8), + ID = c(10, 20) + ) %>% + dplyr::mutate(id = seq(from = 1, to = dplyr::n())) %>% + dplyr::mutate(ThetaQ = TVQ, ThetaV3 = TVV3) %>% + dplyr::rename(NMID = ID) + + tabtot <- dat %>% + dplyr::left_join(., par.tab, by = c("NMID", "id")) + + mod1 <- rxode2({ + ## PK parameters + CL <- exp(ThetaCl) + KA <- exp(ThetaKa) + V2 <- exp(ThetaV2) + Q <- exp(ThetaQ) + V3 <- exp(ThetaV3) + + K20 <- CL / V2 + K23 <- Q / V2 + K32 <- Q / V3 + + CP <- A2 / V2 + + ## + d / dt(A1) <- -KA * A1 + d / dt(A2) <- KA * transit3 - K23 * A2 + K32 * A3 - K20 * A2 + d / dt(A3) <- K23 * A2 - K32 * A3 + + d / dt(transit1) <- KA * A1 - KA * transit1 + d / dt(transit2) <- KA * transit1 - KA * transit2 + d / dt(transit3) <- KA * transit2 - KA * transit3 + + f(A1) <- 1 + + d / dt(AUC) <- CP + A1(0) <- 0 + A2(0) <- 0 + A3(0) <- 0 + + AGE2 <- AGE + }) + + NSubj <- length(tabtot$id) + + dose_ref <- 8000 ## + + ev_ref <- eventTable() %>% + et(dose = dose_ref / 1000, time = seq(0, 24, 24)) %>% + et(id = 1:NSubj) %>% + add.sampling(seq(0, 24, 1)) %>% + dplyr::mutate(DOSE = dose_ref) %>% + dplyr::group_by(id) %>% + tidyr::fill(DOSE, .direction = "downup") %>% + dplyr::ungroup() %>% + dplyr::mutate(Cycle = dplyr::case_when( + time <= 12 ~ 1, # + time >= 12 ~ 2, # + TRUE ~ 0 + )) %>% + dplyr::as_tibble() + + ev_ref <- ev_ref %>% + dplyr::left_join(., tabtot, by = "id") %>% + dplyr::as_tibble() + + PK.ev_ref2 <- rxSolve(mod1, + events = ev_ref, cores = 2, + seed = 123, addCov = TRUE, keep = c("Cycle", "AGE") + ) + + expect_equal(PK.ev_ref2$AGE, PK.ev_ref2$AGE2) }) - NSubj <- length(tabtot$id) - - dose_ref <- 8000 ## - - ev_ref <- eventTable() %>% - et(dose = dose_ref / 1000, time = seq(0, 24, 24)) %>% - et(id = 1:NSubj) %>% - add.sampling(seq(0, 24, 1)) %>% - dplyr::mutate(DOSE = dose_ref) %>% - dplyr::group_by(id) %>% - tidyr::fill(DOSE, .direction = "downup") %>% - dplyr::ungroup() %>% - dplyr::mutate(Cycle = dplyr::case_when( - time <= 12 ~ 1, # - time >= 12 ~ 2, # - TRUE ~ 0 - )) %>% - dplyr::as_tibble() - - ev_ref <- ev_ref %>% - dplyr::left_join(., tabtot, by = "id") %>% - dplyr::as_tibble() - - PK.ev_ref2 <- rxSolve(mod1, - events = ev_ref, cores = 2, - seed = 123, addCov = TRUE, keep = c("Cycle", "AGE") - ) - - expect_equal(PK.ev_ref2$AGE, PK.ev_ref2$AGE2) - }) - - test_that("rxSolve 'keep' maintains character output (#190/#622)", { - - one.cmt <- function() { - ini({ - tka <- 0.45 - tcl <- log(c(0, 2.7, 100)) - tv <- 3.45 - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.sd <- 0.7 + test_that("rxSolve 'keep' maintains character output (#190/#622)", { + + one.cmt <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } + + d <- nlmixr2data::theo_sd + d$SEX <- ifelse(d$ID < 7, "M", "F") + d$fSEX <- factor(d$SEX) + d$oSEX <- d$fSEX + class(d$oSEX) <- c("ordered", "factor") + d$iSEX <- as.integer(d$fSEX) + d$lSEX <- as.logical(d$iSEX == 1) + d$dSEX <- d$iSEX + 0.5 + library(units) + d$uSEX <- set_units(d$dSEX, kg) + d$eSEX <- lapply(d$SEX, function(e) { + str2lang(e) }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - linCmt() ~ add(add.sd) + + sim <- rxSolve(one.cmt, events = d, keep = c("SEX", "fSEX", "iSEX", "dSEX", "oSEX", "uSEX", "lSEX")) + + expect_type(sim$SEX, "character") + expect_s3_class(sim$fSEX, "factor") + expect_equal(levels(sim$fSEX), c("F", "M")) + expect_type(sim$iSEX, "integer") + expect_type(sim$dSEX, "double") + expect_true(inherits(sim$oSEX, "ordered")) + expect_true(inherits(sim$uSEX, "units")) + expect_true(is.logical(sim$lSEX)) + + d <- nlmixr2data::theo_sd + d$SEX <- ifelse(d$ID < 7, "M", "F") + d$SEX[4] <- NA_character_ + d$fSEX <- factor(d$SEX) + d$fSEX[4] <- NA_integer_ + d$iSEX <- as.integer(d$fSEX) + d$iSEX[4] <- NA_integer_ + d$lSEX <- as.logical(d$iSEX == 1) + d$lSEX[4] <- NA + d$dSEX <- d$iSEX + 0.5 + d$eSEX <- lapply(d$SEX, function(e) { + str2lang(e) }) - } - - d <- nlmixr2data::theo_sd - d$SEX <- ifelse(d$ID < 7, "M", "F") - d$fSEX <- factor(d$SEX) - d$oSEX <- d$fSEX - class(d$oSEX) <- c("ordered", "factor") - d$iSEX <- as.integer(d$fSEX) - d$lSEX <- as.logical(d$iSEX == 1) - d$dSEX <- d$iSEX + 0.5 - library(units) - d$uSEX <- set_units(d$dSEX, kg) - d$eSEX <- lapply(d$SEX, function(e) { - str2lang(e) - }) - sim <- rxSolve(one.cmt, events = d, keep = c("SEX", "fSEX", "iSEX", "dSEX", "oSEX", "uSEX", "lSEX")) - - expect_type(sim$SEX, "character") - expect_s3_class(sim$fSEX, "factor") - expect_equal(levels(sim$fSEX), c("F", "M")) - expect_type(sim$iSEX, "integer") - expect_type(sim$dSEX, "double") - expect_true(inherits(sim$oSEX, "ordered")) - expect_true(inherits(sim$uSEX, "units")) - expect_true(is.logical(sim$lSEX)) - - d <- nlmixr2data::theo_sd - d$SEX <- ifelse(d$ID < 7, "M", "F") - d$SEX[4] <- NA_character_ - d$fSEX <- factor(d$SEX) - d$fSEX[4] <- NA_integer_ - d$iSEX <- as.integer(d$fSEX) - d$iSEX[4] <- NA_integer_ - d$lSEX <- as.logical(d$iSEX == 1) - d$lSEX[4] <- NA - d$dSEX <- d$iSEX + 0.5 - d$eSEX <- lapply(d$SEX, function(e) { - str2lang(e) + sim <- rxSolve(one.cmt, events = d, keep = c("SEX", "fSEX", "iSEX", "dSEX", "lSEX")) + + expect_true(is.na(d$SEX[4])) + expect_true(is.na(d$fSEX[4])) + expect_true(is.na(d$iSEX[4])) + expect_true(is.na(d$lSEX[4])) + + expect_error(rxSolve(one.cmt, events = d, keep = c("eSEX"))) + }) - sim <- rxSolve(one.cmt, events = d, keep = c("SEX", "fSEX", "iSEX", "dSEX", "lSEX")) + test_that("rxSolve 'keep' does not crash and keeps correct values #756", { + + qs <- test_path("keep-756.qs") + skip_if_not(file.exists(qs), "Test file not found") + + d <- qs::qread(qs) + + mod <- function() { + ini({ + ka_anon1 <- 1 + f_anon1 <- 0.8 + vc_anon1 <- 3 + hl_anon1 <- 5 + }) + model({ + mw_anon1 <- 55000 + mw_convert_anon1 <- 1 / mw_anon1 * 1e3 + kel_anon1 <- log(2)/(hl_anon1/60/24) + kel_target <- log(2)/1.2 + kform_target <- 1.4*kel_target + kd_anon1_target_umolL <- 1.5/1000 + d/dt(depot_anon1) <- -ka_anon1*depot_anon1 + d/dt(central_anon1) <- ka_anon1*depot_anon1 - kel_anon1*central_anon1 + central_anon1_umolL <- central_anon1/vc_anon1*mw_convert_anon1 + totalconc <- central_anon1_umolL + central_target + kd_anon1_target_umolL + bound_umolL <- (totalconc - sqrt(totalconc^2 - 4*central_anon1_umolL*central_target))/2 + free_central_target <- central_target - bound_umolL + d/dt(central_target) <- kform_target - kel_target*free_central_target - kel_anon1*bound_umolL - 1.1 * (1.3*central_target - peripheral_target) + d/dt(peripheral_target) <- 1.1 * (1.3*central_target - peripheral_target) + d/dt(cleared_amount_bound_anon1_umol) <- kel_anon1*bound_umolL + f(depot_anon1) <- f_anon1 + central_target(0) <- 1.4 + peripheral_target(0) <- 1.4*1.3 + }) + } + + expect_error(rxSolve(mod, d, keep="target_name"), NA) + + tmp <- rxSolve(mod, d, keep="target_name", addDosing=FALSE) + + expect_false(any(is.na(tmp$target_name))) - expect_true(is.na(d$SEX[4])) - expect_true(is.na(d$fSEX[4])) - expect_true(is.na(d$iSEX[4])) - expect_true(is.na(d$lSEX[4])) + tmp <- rxSolve(mod, d, keep="target_name", addDosing=TRUE, keepInterpolation="na") - expect_error(rxSolve(one.cmt, events = d, keep = c("eSEX"))) + expect_true(any(is.na(tmp$target_name))) - }) -} + tmp <- rxSolve(mod, d, keep="target_name", addDosing=TRUE, keepInterpolation="locf") + + expect_false(any(is.na(tmp$target_name))) + + tmp <- rxSolve(mod, d, keep="target_name", addDosing=TRUE, keepInterpolation="nocb") + + expect_false(any(is.na(tmp$target_name))) + + + ## print(head(tmp[,c("id", "amt", "target_name")])) + + et <- etTrans(d, mod, keep="target_name") + et2 <- attr(class(et), ".rxode2.lst") + class(et2) <- NULL + + expect_equal(length(et2$keepL$keepL[[1]]), + length(et$ID)) + + class(et) <- "data.frame" + et <- cbind(et, k=et2$keepL$keepL[[1]]) + + d2 <- d %>% dplyr::filter(EVID==1) %>% dplyr::select(ID, TIME) %>% + dplyr::mutate(i=1) + + # only variables in the dataset are considered NA + expect_true(merge(et, d2, all.x=TRUE) %>% + dplyr::filter(i!= 1) %>% dplyr::pull(k) %>% all(is.na(.))) + + ## s <- rxSolve(mod, d, keep="target_name") + + }) + } +}) diff --git a/tests/testthat/test-lhs-str.R b/tests/testthat/test-lhs-str.R new file mode 100644 index 000000000..41e533d9a --- /dev/null +++ b/tests/testthat/test-lhs-str.R @@ -0,0 +1,423 @@ +rxTest({ + test_that("test lhs string assign lhs expression information", { + p <- rxode2parse('a="oh no"') + expect_equal(p$lhs, "a") + expect_equal(p$slhs, character(0)) + expect_equal(p$strAssign, list(a = "oh no")) + + p <- rxode2parse('a<-"oh no"') + expect_equal(p$lhs, "a") + expect_equal(p$slhs, character(0)) + expect_equal(p$strAssign, list(a = "oh no")) + + p <- rxode2parse('a~"oh no"') + expect_equal(p$slhs, "a") + expect_equal(p$lhs, character(0)) + expect_equal(p$strAssign, list(a = "oh no")) + + p <- rxode2parse('a<-"oh no"\nb<-3+40') + expect_equal(p$lhs, c("a", "b")) + expect_equal(p$slhs, character(0)) + expect_equal(p$strAssign, list(a = "oh no")) + expect_equal(p$lhsStr, c(a = TRUE, b = FALSE)) + + p <- rxode2parse(' +if (APGAR == 10 || APGAR == 8 || APGAR == 9) { + tAPGAR <- "High" + } else if (APGAR == 1 || APGAR == 2 || APGAR == 3) { + tAPGAR <- "Low" + } else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) { + tAPGAR <- "Med" + } else { + tAPGAR<- "Med" + } +') + + expect_equal(p$strAssign, list(tAPGAR = c("High", "Low", "Med"))) + expect_equal(p$lhsStr, c(tAPGAR = TRUE)) + expect_equal(p$lhs, "tAPGAR") + expect_equal(p$slhs, character(0)) + expect_equal(p$params , "APGAR") + expect_equal(p$model["normModel"], + c(normModel = "if (APGAR==10||APGAR==8||APGAR==9){\ntAPGAR <-\"High\";\n}\nelse {\nif (APGAR==1||APGAR==2||APGAR==3){\ntAPGAR <-\"Low\";\n}\nelse {\nif (APGAR==4||APGAR==5||APGAR==6||APGAR==7){\ntAPGAR <-\"Med\";\n}\nelse {\ntAPGAR <-\"Med\";\n}\n}\n}\n")) + + + p <- rxode2parse(' +if (APGAR == 10 || APGAR == 8 || APGAR == 9) { + tAPGAR <- "High" + } else if (APGAR == 1 || APGAR == 2 || APGAR == 3) { + tAPGAR <- "Low" + } else if (APGAR == 4 || APGAR == 5 || APGAR == 6 || APGAR == 7) { + tAPGAR <- "Med" + } else { + tAPGAR<- "Med" + } + tAPGAR <- 1 +') + + p <- rxode2parse('levels(tAPGAR) <- c("High", "Med", "Low")\ntAPGAR <- "Low"') + + expect_equal(p$strAssign, list(tAPGAR = c("High", "Med", "Low"))) + expect_equal(p$lhsStr, c(tAPGAR = TRUE)) + expect_equal(p$lhs, "tAPGAR") + expect_equal(p$slhs, character(0)) + expect_equal(p$model["normModel"], + c(normModel = "levels(tAPGAR) <- c(\"High\", \"Med\", \"Low\");\ntAPGAR <-\"Low\";\n")) + + }) + + + f <- function() { + expect_error(rxode2parse('a <- "matt"; a<- 2')) + expect_error(rxode2parse('a <- "matt"; a<- 1'), NA) + expect_error(rxode2parse('a <- "matt"; a <- "rxode2"; a<- 2'), NA) + expect_error(rxode2parse('a <- "matt"; a <- "rxode2"; a<- 3')) + expect_error(rxode2parse('a <- "matt"; a(0)<- 2')) + expect_error(rxode2parse('a <- b; a <- "str"')) + expect_error(rxode2parse('a <- 1; a <- "str"')) + expect_error(rxode2parse("d/dt(a) <- -kel; a <- \"str\"")) + expect_error(rxode2parse("rate(a) <- -kel; a <- \"str\"")) + expect_error(rxode2parse("dur(a) <- -kel; a <- \"str\"")) + expect_error(rxode2parse("alag(a) <- -kel; a <- \"str\"")) + expect_error(rxode2parse("a(0) <- -kel; a <- \"str\"")) + expect_error(rxode2parse("a(0) <- 1; a <- \"str\"")) + expect_error(rxode2parse('a <- "matt"; d/dt(a)<- 2')) + expect_error(rxode2parse('a <- "matt"; rate(a)<- 2')) + expect_error(rxode2parse('a <- "matt"; dur(a)<- 2')) + expect_error(rxode2parse('a <- "matt"; alag(a)<- 2')) + expect_error(rxode2parse("a <- \"str\"; a(0) <- -kel")) + expect_error(rxode2parse("a <- \"str\"; a(0) <- 1")) + # so that pruned expressions can work + expect_error(rxode2parse("a <- \"str\"; a <- 1+5"), NA) + expect_error(rxode2parse("a <- \"str\"; a <- -1+5"), NA) + expect_error(rxode2parse("a <- \"str\"; a <- +1+5"), NA) + } + + test_that("test lhs string assign rxode2.syntax.allow.ini=TRUE", { + withr::with_options(list(rxode2.syntax.allow.ini=TRUE, + rxode2.syntax.require.ode.first = FALSE), { + f() + }) + }) + + test_that("test lhs string assign rxode2.syntax.allow.ini=FALSE", { + withr::with_options(list(rxode2.syntax.allow.ini=FALSE, + rxode2.syntax.require.ode.first = FALSE), { + f() + }) + }) + + test_that("lhs solve; tests lhs assign & str equals with lhs", { + + rx <- rxode2({ + if (t < 10) { + a <- "<10" + } else { + a <- ">=10" + } + b <- 1 + if (a == "<10") { + b <- 0; + } + }) + + e <- et(1:20) + + s <-rxSolve(rx, e, returnType = "data.frame") + + expect_true(all(s$a[s$time < 10] == "<10")) + expect_true(all(s$a[s$time >= 10] == ">=10")) + expect_true(all(s$b[s$time < 10] == 0)) + expect_true(all(s$b[s$time >= 10] == 1)) + }) + + test_that("out of bounds solve gives NA for factors", { + + rx <- rxode2({ + if (t < 10) { + a <- "<10" + } else { + a <- ">=10" + } + a <- 1-3 + b <- 1 + if (a == "<10") { + b <- 0; + } + }) + + e <- et(1:20) + + s <-rxSolve(rx, e, returnType = "data.frame") + + expect_true(all(is.na(s$a))) + + rx <- rxode2({ + if (t < 10) { + a <- "<10" + } else { + a <- ">=10" + } + a <- 1+20 + b <- 1 + if (a == "<10") { + b <- 0; + } + }) + + s <-rxSolve(rx, e, returnType = "data.frame") + + expect_true(all(is.na(s$a))) + + + }) + + + test_that("lhs solve; tests lhs levels & str equals with lhs", { + + rx <- rxode2({ + levels(a) <- c("<10", ">=10") + if (t < 10) { + a <- 1 + } else { + a <- 2 + } + b <- 1 + if (a == "<10") { + b <- 0; + } + }) + + e <- et(1:20) + + s <-rxSolve(rx, e, returnType = "data.frame") + + expect_true(all(s$a[s$time < 10] == "<10")) + expect_true(all(s$a[s$time >= 10] == ">=10")) + expect_true(all(s$b[s$time < 10] == 0)) + expect_true(all(s$b[s$time >= 10] == 1)) + + }) + + + test_that("levels1 statement solve", { + + rx <- rxode2({ + levels(a) <- "<10" + if (t < 10) { + a <- 1 + } else { + a <- ">=10" + } + b <- 1 + if (a == "<10") { + b <- 0; + } + }) + + e <- et(1:20) + + s <-rxSolve(rx, e, returnType = "data.frame") + + expect_true(all(s$a[s$time < 10] == "<10")) + expect_true(all(s$a[s$time >= 10] == ">=10")) + expect_true(all(s$b[s$time < 10] == 0)) + expect_true(all(s$b[s$time >= 10] == 1)) + + }) + + test_that("levels extraction", { + + rx <- function() { + model({ + levels(a) <- c("<10", ">=10") + if (t < 10) { + a <- 1 + } else { + a <- 2 + } + b <- 1 + if (a == "<10") { + b <- 2; + } + }) + } + + rx <- rx() + + expect_equal(rx$levels, + list(str2lang("levels(a) <- c(\"<10\", \">=10\")"))) + + rx <- function() { + model({ + levels(a) <- c("<10", ">=10") + levels(b) <- c("low", "high") + if (t < 10) { + a <- 1 + } else { + a <- 2 + } + b <- 1 + if (a == "<10") { + b <- 2; + } + }) + } + + rx <- rx() + + expect_equal(rx$levels, + list(str2lang("levels(a) <- c(\"<10\", \">=10\")"), + str2lang("levels(b) <- c(\"low\", \"high\")"))) + + + rx <- function() { + model({ + levels(a) <- c("<10", ">=10") + levels(b) <- c("low", "high") + levels(c) <- c("funny") + if (t < 10) { + a <- 1 + } else { + a <- 2 + } + b <- 1 + if (a == "<10") { + b <- 2; + } + c <- 1 + }) + } + + rx <- rx() + + expect_equal(rx$levels, + list(str2lang("levels(a) <- c(\"<10\", \">=10\")"), + str2lang("levels(b) <- c(\"low\", \"high\")"), + str2lang("levels(c) <- \"funny\""))) + + }) + + test_that("test symengine translation to integers", { + + v <-rxModelVars(" +levels(a) <- c(\"<10\", \">=10\") +b <- (a == \"<10\")*1 + (a == \">=10\")*2 +") + + s <- rxS(v) + v <- as.character(s$b) + expect_error(rxFromSE(v), NA) + + expect_equal(.rxPrune(str2lang("{a<-'a'; b<-1}"), + strAssign=list(a = "a")), + "a<-1\nb<-1") + + expect_equal(.rxPrune(str2lang("{a<-'a'; b<-1}"), + strAssign=list(a = c("b", "a"))), + "a<-2\nb<-1") + + expect_equal(.rxPrune(str2lang("{a<-'a'; b<-1}"), + strAssign=list(c = c("b", "a"))), + "a<-\"a\"\nb<-1") + + expect_equal(.rxPrune(str2lang("{b <- (a == 'a')}"), + strAssign=list(c = c("b", "a"))), + "b<-(a==\"a\")") + + expect_equal(.rxPrune(str2lang("{b <- (a == 'a')}"), + strAssign=list(a = c("b", "a"))), + "b<-(a==2)") + + expect_equal(.rxPrune(str2lang("{b <- (a == 'a')}"), + strAssign=list(a = c("a"))), + "b<-(a==1)") + + ## No test the other direction + expect_equal(.rxPrune(str2lang("{b <- ('a' == a)}"), + strAssign=list(c = c("b", "a"))), + "b<-(\"a\"==a)") + + expect_equal(.rxPrune(str2lang("{b <- ('a' == a)}"), + strAssign=list(a = c("b", "a"))), + "b<-(2==a)") + + expect_equal(.rxPrune(str2lang("{b <- ('a' == a)}"), + strAssign=list(a = c("a"))), + "b<-(1==a)") + + + ## neq + expect_equal(.rxPrune(str2lang("{b <- (a != 'a')}"), + strAssign=list(c = c("b", "a"))), + "b<-(a!=\"a\")") + + expect_equal(.rxPrune(str2lang("{b <- (a != 'a')}"), + strAssign=list(a = c("b", "a"))), + "b<-(a!=2)") + + expect_equal(.rxPrune(str2lang("{b <- (a != 'a')}"), + strAssign=list(a = c("a"))), + "b<-(a!=1)") + + ## No test the other direction + expect_equal(.rxPrune(str2lang("{b <- ('a' != a)}"), + strAssign=list(c = c("b", "a"))), + "b<-(\"a\"!=a)") + + expect_equal(.rxPrune(str2lang("{b <- ('a' != a)}"), + strAssign=list(a = c("b", "a"))), + "b<-(2!=a)") + + expect_equal(.rxPrune(str2lang("{b <- ('a' != a)}"), + strAssign=list(a = c("a"))), + "b<-(1!=a)") + + }) + + + test_that("simulation model will include string information", { + + f <- function() { + ini({ + tka <- 0.45 + tcl <- log(c(0, 2.7, 100)) + tv <- 3.45 + cl.wt <- 0 + v.wt <- 0 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.sd <- 0.7 + }) + model({ + if (time > 10) { + timeText <- "time > 10" + } else { + timeText <- "time <= 10" + } + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl)+ WT ^ 2* cl.wt + v <- exp(tv + eta.v+ WT * v.wt + b + c + d) + linCmt() ~ add(add.sd) + }) + } + + ui <- rxode(f) + + expect_error(ui$simulationModel, NA) + + mod <- ui$simulationModel + + expect_equal(rxModelVars(mod)$strAssign, + list(timeText = c("time > 10", "time <= 10"))) + + expect_error(ui$simulationIniModel, NA) + + mod <- ui$simulationIniModel + + expect_equal(rxModelVars(mod)$strAssign, + list(timeText = c("time > 10", "time <= 10"))) + + }) +}) diff --git a/tests/testthat/test-lock.R b/tests/testthat/test-lock.R index 84a6c2c8d..4abf04792 100644 --- a/tests/testthat/test-lock.R +++ b/tests/testthat/test-lock.R @@ -1,38 +1,40 @@ -if (!.Call(`_rxode2_isIntel`)) { - # locking tests +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + # locking tests - ode <- rxode2({ - a <- -8 / 3 - b <- -10 - c <- -1 - d / dt(X) <- a * X + Y * Z - d / dt(Y) <- b * (Y - Z) - d / dt(Z) <- -X * Y + c * Y - Z - }) + ode <- rxode2({ + a <- -8 / 3 + b <- -10 + c <- -1 + d / dt(X) <- a * X + Y * Z + d / dt(Y) <- b * (Y - Z) + d / dt(Z) <- -X * Y + c * Y - Z + }) - test_that("Unlocked when simply loading", { - expect_true(rxModels_()[[rxDll(ode)]] == 0L) - }) + test_that("Unlocked when simply loading", { + expect_true(rxModels_()[[rxDll(ode)]] == 0L) + }) - et <- eventTable(time.units = "hr") # default time units - et$add.sampling(seq(from = 0, to = 100, by = 0.01)) + et <- eventTable(time.units = "hr") # default time units + et$add.sampling(seq(from = 0, to = 100, by = 0.01)) - out <- rxSolve(ode, - events = et, - inits = c(X = 1, Y = 1, Z = 1), - .setupOnly = TRUE - ) + out <- rxSolve(ode, + events = et, + inits = c(X = 1, Y = 1, Z = 1), + .setupOnly = TRUE + ) - test_that("Locked after .setupOnly", { - expect_true(rxModels_()[[rxDll(ode)]] == 1L) - }) + test_that("Locked after .setupOnly", { + expect_true(rxModels_()[[rxDll(ode)]] == 1L) + }) - out <- rxSolve(ode, - events = et, - inits = c(X = 1, Y = 1, Z = 1) - ) + out <- rxSolve(ode, + events = et, + inits = c(X = 1, Y = 1, Z = 1) + ) - test_that("Unlocked after other solve", { - expect_true(rxModels_()[[rxDll(ode)]] == 0L) - }) -} + test_that("Unlocked after other solve", { + expect_true(rxModels_()[[rxDll(ode)]] == 0L) + }) + } +}) diff --git a/tests/testthat/test-logical.R b/tests/testthat/test-logical.R index 8821df163..bb7bd39c0 100644 --- a/tests/testthat/test-logical.R +++ b/tests/testthat/test-logical.R @@ -1,22 +1,24 @@ -if (!.Call(`_rxode2_isIntel`)) { - # Logical expressions test +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + # Logical expressions test - transTo <- function(model, syntax, match = TRUE) { - mod <- rxModelVars(model) + transTo <- function(model, syntax, match = TRUE) { + mod <- rxModelVars(model) - if (match) { - test_that(sprintf("%s includes %s", model, syntax), { - expect_true(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) - }) - } else { - test_that(sprintf("%s dose not include %s", model, syntax), { - expect_false(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) - }) + if (match) { + test_that(sprintf("%s includes %s", model, syntax), { + expect_true(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) + }) + } else { + test_that(sprintf("%s dose not include %s", model, syntax), { + expect_false(regexpr(syntax, .rxGetParseModel(), fixed = TRUE) != -1) + }) + } } - } - transTo("x=1;if (t != 0 & t != 1){x=0}", "&&") - transTo("x=1;if ((t == 0) | (t == 1)){x=0}", "||") - transTo("x=1;if ((t == 0) & !(t == 1)){x=0}", "&&") - transTo("x=1;if ((t == 0) & !(t == 1)){x=0}", "!(") -} + transTo("x=1;if (t != 0 & t != 1){x=0}", "&&") + transTo("x=1;if ((t == 0) | (t == 1)){x=0}", "||") + transTo("x=1;if ((t == 0) & !(t == 1)){x=0}", "&&") + transTo("x=1;if ((t == 0) & !(t == 1)){x=0}", "!(") + } +}) diff --git a/tests/testthat/test-logit.R b/tests/testthat/test-logit.R index 50ed3f0b8..0b3573985 100644 --- a/tests/testthat/test-logit.R +++ b/tests/testthat/test-logit.R @@ -51,8 +51,15 @@ rxTest({ expect_equal(logit(1:10, 0L, 11L), logit(as.double(1:10), 0.0, 11.0)) - expect_error(logit(0.5, c(1, 2))) - expect_error(logit(0.5, 0, c(1, 2))) + expect_equal(logit(7, c(1, 2), c(10, 114)), + c(logit(7, 1, 10), + logit(7, 2, 114))) + + expect_error(.Call(`_rxode2_powerD`, 0.5, c(1, 2), 3, 4, 4L, TRUE)) + expect_error(.Call(`_rxode2_powerD`, 0.5, 1, c(3, 4), 4, 4L, TRUE)) + expect_error(.Call(`_rxode2_powerD`, 0.5, 1, 3, 4, c(4L, 5L), TRUE)) + expect_error(.Call(`_rxode2_powerD`, 0.5, 1, 3, 4, 4L, c(TRUE, FALSE))) + expect_error(logit(0.5, 1, -2)) }) @@ -107,9 +114,5 @@ rxTest({ ) expect_equal(expit(1:10, 0L, 11L), expit(as.double(1:10), 0.0, 11.0)) - - expect_error(expit(0.5, c(1, 2))) - expect_error(expit(0.5, 0, c(1, 2))) - expect_error(expit(0.5, 1, -2)) }) }) diff --git a/tests/testthat/test-mdv.R b/tests/testthat/test-mdv.R index 817097ffb..a0693fbdb 100644 --- a/tests/testthat/test-mdv.R +++ b/tests/testthat/test-mdv.R @@ -1,28 +1,30 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("mdv means EVID=2 when amt=0", { - theoSd <- nlmixr2data::theo_sd +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("mdv means EVID=2 when amt=0", { + theoSd <- nlmixr2data::theo_sd - d <- theoSd[, names(theoSd) != "EVID"] - d$MDV <- ifelse(d$AMT == 0, 0, 1) - d <- d[, names(d) != "WT"] + d <- theoSd[, names(theoSd) != "EVID"] + d$MDV <- ifelse(d$AMT == 0, 0, 1) + d <- d[, names(d) != "WT"] - d2 <- expand.grid(ID = 1:12, TIME = c(0.125, 25), DV = 0, AMT = 0, CMT = 2, MDV = 1) + d2 <- expand.grid(ID = 1:12, TIME = c(0.125, 25), DV = 0, AMT = 0, CMT = 2, MDV = 1) - d <- rbind(d, d2) + d <- rbind(d, d2) - mod <- rxode2({ - tka <- 1 - tcl <- 2 - tv <- 3 - ka <- exp(tka) - cl <- exp(tcl) - v <- exp(tv) - cp <- linCmt() - }) + mod <- rxode2({ + tka <- 1 + tcl <- 2 + tv <- 3 + ka <- exp(tka) + cl <- exp(tcl) + v <- exp(tv) + cp <- linCmt() + }) - tmp <- rxSolve(mod, d) + tmp <- rxSolve(mod, d) - expect_true(any(tmp$time == 0.125)) - expect_true(any(tmp$time == 25)) - }) -} + expect_true(any(tmp$time == 0.125)) + expect_true(any(tmp$time == 25)) + }) + } +}) diff --git a/tests/testthat/test-meanProb.R b/tests/testthat/test-meanProb.R index 47f44d72c..7e9d56038 100644 --- a/tests/testthat/test-meanProb.R +++ b/tests/testthat/test-meanProb.R @@ -1,118 +1,120 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("test meanProb()", { +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("test meanProb()", { - x <- rnorm(10) - m <- mean(x) - s <- sd(x) - v <- var(x) - mn <- min(x) - mx <- max(x) - t1 <- c("0%"=mn, "25%"=m+(s/sqrt(10))*qt(0.25, 9), "50%"=m, "75%"=m+(s/sqrt(10))*qt(0.75, 9), "100%"=mx) - expect_equal(meanProbs(x), t1) + x <- rnorm(10) + m <- mean(x) + s <- sd(x) + v <- var(x) + mn <- min(x) + mx <- max(x) + t1 <- c("0%"=mn, "25%"=m+(s/sqrt(10))*qt(0.25, 9), "50%"=m, "75%"=m+(s/sqrt(10))*qt(0.75, 9), "100%"=mx) + expect_equal(meanProbs(x), t1) - t1.100 <- c("0%"=mn, "25%"=m+(s/sqrt(100))*qt(0.25, 99), "50%"=m, "75%"=m+(s/sqrt(100))*qt(0.75, 99), "100%"=mx) - expect_equal(meanProbs(x, n=100), t1.100) + t1.100 <- c("0%"=mn, "25%"=m+(s/sqrt(100))*qt(0.25, 99), "50%"=m, "75%"=m+(s/sqrt(100))*qt(0.75, 99), "100%"=mx) + expect_equal(meanProbs(x, n=100), t1.100) - t1.p100 <- c("0%"=mn, "25%"=m+s*sqrt(1.0+(1.0/100))*qt(0.25, 99), "50%"=m, "75%"=m+s*sqrt(1.0+(1.0/100))*qt(0.75, 99), "100%"=mx) - expect_equal(meanProbs(x, n=100, pred=TRUE), t1.p100) + t1.p100 <- c("0%"=mn, "25%"=m+s*sqrt(1.0+(1.0/100))*qt(0.25, 99), "50%"=m, "75%"=m+s*sqrt(1.0+(1.0/100))*qt(0.75, 99), "100%"=mx) + expect_equal(meanProbs(x, n=100, pred=TRUE), t1.p100) - t2 <- c(c("mean"=m, "var"=v, "sd"=s, "min"=mn, "max"=mx, "n"=10), t1) - expect_equal(meanProbs(x, onlyProbs=FALSE), t2) - x2 <- c(x, NA_real_) - setNames(rep(NA_real_, length(t1)),names(t1)) + t2 <- c(c("mean"=m, "var"=v, "sd"=s, "min"=mn, "max"=mx, "n"=10), t1) + expect_equal(meanProbs(x, onlyProbs=FALSE), t2) + x2 <- c(x, NA_real_) + setNames(rep(NA_real_, length(t1)),names(t1)) - expect_equal(meanProbs(x2), setNames(rep(NA_real_, length(t1)),names(t1))) + expect_equal(meanProbs(x2), setNames(rep(NA_real_, length(t1)),names(t1))) - expect_equal(meanProbs(x2, onlyProbs=FALSE), - setNames(rep(NA_real_, length(t2)),names(t2))) + expect_equal(meanProbs(x2, onlyProbs=FALSE), + setNames(rep(NA_real_, length(t2)),names(t2))) - expect_equal(meanProbs(x2, na.rm=TRUE), t1) + expect_equal(meanProbs(x2, na.rm=TRUE), t1) - expect_equal(meanProbs(x2, onlyProbs=FALSE, na.rm=TRUE), t2) + expect_equal(meanProbs(x2, onlyProbs=FALSE, na.rm=TRUE), t2) - mod <- rxode2({ - d/dt(intestine) <- -a * intestine - d/dt(blood) <- a * intestine - b * blood - }) + mod <- rxode2({ + d/dt(intestine) <- -a * intestine + d/dt(blood) <- a * intestine - b * blood + }) - et <- eventTable() - et$add.sampling(seq(0, 10, length.out = 50)) - et$add.dosing( - dose = 2/24, rate = 2, strt.time = 0, - nbr.doses = 10, dosing.interval = 1 - ) + et <- eventTable() + et$add.sampling(seq(0, 10, length.out = 50)) + et$add.dosing( + dose = 2/24, rate = 2, strt.time = 0, + nbr.doses = 10, dosing.interval = 1 + ) - p <- data.frame(a = 6, b = seq(0.4, 0.9, length.out = 4)) + p <- data.frame(a = 6, b = seq(0.4, 0.9, length.out = 4)) - pk1 <- suppressWarnings(rxSolve(mod, p, et, cores = 1)) + pk1 <- suppressWarnings(rxSolve(mod, p, et, cores = 1)) - ci1 <- confint(pk1, "blood", mean=TRUE) + ci1 <- confint(pk1, "blood", mean=TRUE) - # use dplyr - ci2 <- pk1 |> - dplyr::group_by(time) |> - dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE), - p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> - dplyr::arrange(time, p1) + # use dplyr + ci2 <- pk1 |> + dplyr::group_by(time) |> + dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE), + p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> + dplyr::arrange(time, p1) - expect_equal(ci1$eff, ci2$eff) + expect_equal(ci1$eff, ci2$eff) - ci1 <- confint(pk1, "blood", mean=TRUE, pred=TRUE) + ci1 <- confint(pk1, "blood", mean=TRUE, pred=TRUE) - ci2 <- pk1 |> - dplyr::group_by(time) |> - dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, pred=TRUE), - p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> - dplyr::arrange(time, p1) + ci2 <- pk1 |> + dplyr::group_by(time) |> + dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, pred=TRUE), + p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> + dplyr::arrange(time, p1) - expect_equal(ci1$eff, ci2$eff) + expect_equal(ci1$eff, ci2$eff) - ci1 <- confint(pk1, "blood", mean=TRUE, n=100) + ci1 <- confint(pk1, "blood", mean=TRUE, n=100) - ci2 <- pk1 |> - dplyr::group_by(time) |> - dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, - n=100), - p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> - dplyr::arrange(time, p1) + ci2 <- pk1 |> + dplyr::group_by(time) |> + dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, + n=100), + p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> + dplyr::arrange(time, p1) - expect_equal(ci1$eff, ci2$eff) + expect_equal(ci1$eff, ci2$eff) - ci1 <- confint(pk1, "blood", mean=TRUE, pred=TRUE, n=100) + ci1 <- confint(pk1, "blood", mean=TRUE, pred=TRUE, n=100) - ci2 <- pk1 |> - dplyr::group_by(time) |> - dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, - pred=TRUE, n=100), - p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> - dplyr::arrange(time, p1) + ci2 <- pk1 |> + dplyr::group_by(time) |> + dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, + pred=TRUE, n=100), + p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> + dplyr::arrange(time, p1) - expect_equal(ci1$eff, ci2$eff) + expect_equal(ci1$eff, ci2$eff) - ci1 <- confint(pk1, "blood", mean=TRUE, useT=FALSE) + ci1 <- confint(pk1, "blood", mean=TRUE, useT=FALSE) - # use dplyr - ci2 <- pk1 |> - dplyr::group_by(time) |> - dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, useT=FALSE), - p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> - dplyr::arrange(time, p1) + # use dplyr + ci2 <- pk1 |> + dplyr::group_by(time) |> + dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, useT=FALSE), + p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> + dplyr::arrange(time, p1) - expect_equal(ci1$eff, ci2$eff) + expect_equal(ci1$eff, ci2$eff) - ci1 <- confint(pk1, "blood", mean=TRUE, useT=FALSE, pred=TRUE) + ci1 <- confint(pk1, "blood", mean=TRUE, useT=FALSE, pred=TRUE) - # use dplyr - ci2 <- pk1 |> - dplyr::group_by(time) |> - dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, useT=FALSE, - pred=TRUE), - p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> - dplyr::arrange(time, p1) + # use dplyr + ci2 <- pk1 |> + dplyr::group_by(time) |> + dplyr::reframe(eff=meanProbs(blood, c(0.025, 0.5, 0.975), na.rm=TRUE, names=FALSE, useT=FALSE, + pred=TRUE), + p1=c(0.025, 0.5, 0.975), Percentile=c("2.5%", "50%", "97.5%")) |> + dplyr::arrange(time, p1) - expect_equal(ci1$eff, ci2$eff) + expect_equal(ci1$eff, ci2$eff) - }) -} + }) + } +}) diff --git a/tests/testthat/test-mtime.R b/tests/testthat/test-mtime.R index 792e8c2f5..4b6676da6 100644 --- a/tests/testthat/test-mtime.R +++ b/tests/testthat/test-mtime.R @@ -1,36 +1,38 @@ -if (!.Call(`_rxode2_isIntel`)) { - mod <- rxode2({ - ka <- 0.04 - kel <- 0.6 - mt1 <- 0.04 - mt2 <- 0.6 - mtime(t1) <- mt1 - mtime(t2) <- mt2 - if (t >= t1) { - ka <- 0.4 - } - if (t >= t2) { - ka <- 4 - } - d / dt(intestine) <- -ka * intestine - d / dt(blood) <- ka * intestine - kel * blood - }) +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + mod <- rxode2({ + ka <- 0.04 + kel <- 0.6 + mt1 <- 0.04 + mt2 <- 0.6 + mtime(t1) <- mt1 + mtime(t2) <- mt2 + if (t >= t1) { + ka <- 0.4 + } + if (t >= t2) { + ka <- 4 + } + d / dt(intestine) <- -ka * intestine + d / dt(blood) <- ka * intestine - kel * blood + }) - et <- eventTable() %>% - add.dosing(dose = 3, nbr.doses = 1) %>% - add.sampling(0:48) + et <- eventTable() %>% + add.dosing(dose = 3, nbr.doses = 1) %>% + add.sampling(0:48) - test_that("Solved model contains the model times", { - s <- solve(mod, et) - expect_true(any(s$time == 0.04)) - expect_true(any(s$time == 0.6)) - expect_false(any(s$time == 1.977)) - expect_false(any(s$time == 10.99)) - s <- solve(mod, et, c(mt1 = 1.977, mt2 = 10.09)) - expect_true(any(s$time == 1.977)) - expect_true(any(s$time == 10.09)) - expect_false(any(s$time == 0.04)) - expect_false(any(s$time == 0.6)) - }) -} + test_that("Solved model contains the model times", { + s <- solve(mod, et) + expect_true(any(s$time == 0.04)) + expect_true(any(s$time == 0.6)) + expect_false(any(s$time == 1.977)) + expect_false(any(s$time == 10.99)) + s <- solve(mod, et, c(mt1 = 1.977, mt2 = 10.09)) + expect_true(any(s$time == 1.977)) + expect_true(any(s$time == 10.09)) + expect_false(any(s$time == 0.04)) + expect_false(any(s$time == 0.6)) + }) + } +}) diff --git a/tests/testthat/test-mu2.R b/tests/testthat/test-mu2.R index 6bd819be2..80f7fb85f 100644 --- a/tests/testthat/test-mu2.R +++ b/tests/testthat/test-mu2.R @@ -1,55 +1,57 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("mu2 referencing", { +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("mu2 referencing", { - f <- function() { - ini({ - tka <- 0.45644793862596 - label("Log Ka") - tcl <- 1.0158342238421 - label("Log Cl") - tv <- 3.45168722356501 - label("Log V") - add.sd <- c(0, 0.693865857699365) - wt_cl <- fix(0.75) - eta.ka ~ 0.413242125585966 - eta.cl ~ 0.0700506402691836 - eta.v ~ 0.0190586604340742 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl + wt_cl * log(WT/70.5)) - v <- exp(tv + eta.v) - linCmt() ~ add(add.sd) - }) - } + f <- function() { + ini({ + tka <- 0.45644793862596 + label("Log Ka") + tcl <- 1.0158342238421 + label("Log Cl") + tv <- 3.45168722356501 + label("Log V") + add.sd <- c(0, 0.693865857699365) + wt_cl <- fix(0.75) + eta.ka ~ 0.413242125585966 + eta.cl ~ 0.0700506402691836 + eta.v ~ 0.0190586604340742 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl + wt_cl * log(WT/70.5)) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } - f <- f() + f <- f() - model.BASE <- function() { - ini({ - tka <- log(1) # Log Ka - tcl <- log(2) # Log Cl - tv <- log(20) # Log V - eta.ka ~ 0.5 - eta.cl ~ 0.1 - eta.v ~ 0.1 - add.sd <- 0.5 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - linCmt() ~ add(add.sd) - }) - } + model.BASE <- function() { + ini({ + tka <- log(1) # Log Ka + tcl <- log(2) # Log Cl + tv <- log(20) # Log V + eta.ka ~ 0.5 + eta.cl ~ 0.1 + eta.v ~ 0.1 + add.sd <- 0.5 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } - m2 <- model.BASE %>% - model(cl <- exp(tcl + eta.cl + wt_cl*log(WT/70.5))) %>% - ini(wt_cl <- fix(0.75)) + m2 <- model.BASE %>% + model(cl <- exp(tcl + eta.cl + wt_cl*log(WT/70.5))) %>% + ini(wt_cl <- fix(0.75)) - expect_equal(f$mu2RefCovariateReplaceDataFrame, - m2$mu2RefCovariateReplaceDataFrame) + expect_equal(f$mu2RefCovariateReplaceDataFrame, + m2$mu2RefCovariateReplaceDataFrame) - }) -} + }) + } +}) diff --git a/tests/testthat/test-nearpd.R b/tests/testthat/test-nearpd.R index a5e34fbda..4daea824c 100644 --- a/tests/testthat/test-nearpd.R +++ b/tests/testthat/test-nearpd.R @@ -60,7 +60,3 @@ rxTest({ NA) }) }) - -test_that(".nearPD expected null for matrix that cannot become positive definite", { - expect_null(.nearPD(matrix(Inf))) -}) diff --git a/tests/testthat/test-newind.R b/tests/testthat/test-newind.R index 92896c5a5..d01db9969 100644 --- a/tests/testthat/test-newind.R +++ b/tests/testthat/test-newind.R @@ -1,42 +1,44 @@ -if (!.Call(`_rxode2_isIntel`)) { - # test newind flag - ode.1c <- rxode2({ - V <- 20 - Cl <- 1 - fc <- 1 - C2 <- center / V - ni <- newind - ni2 <- NEWIND - d / dt(center) ~ -Cl * C2 - f(center) <- fc - }) +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + # test newind flag + ode.1c <- rxode2({ + V <- 20 + Cl <- 1 + fc <- 1 + C2 <- center / V + ni <- newind + ni2 <- NEWIND + d / dt(center) ~ -Cl * C2 + f(center) <- fc + }) - et <- eventTable() %>% - add.dosing(dose = 3, nbr.doses = 6, dosing.interval = 8) %>% - add.sampling(0:4) + et <- eventTable() %>% + add.dosing(dose = 3, nbr.doses = 6, dosing.interval = 8) %>% + add.sampling(0:4) - et2 <- eventTable() %>% - add.dosing(start.time = 0.5, dose = 3, nbr.doses = 6, dosing.interval = 8) %>% - add.sampling(0:4) + et2 <- eventTable() %>% + add.dosing(start.time = 0.5, dose = 3, nbr.doses = 6, dosing.interval = 8) %>% + add.sampling(0:4) - ms <- c("liblsoda", "lsoda", "dop853") + ms <- c("liblsoda", "lsoda", "dop853") - for (m in ms) { - s <- solve(ode.1c, et, addDosing = TRUE, method = m) - test_that("ode newind works with dose first", { - expect_equal(s$ni[1], 1L) - expect_equal(s$ni2[1], 1L) - expect_true(all(s$ni[-1] == 2)) - expect_true(all(s$ni2[-1] == 2)) - }) + for (m in ms) { + s <- solve(ode.1c, et, addDosing = TRUE, method = m) + test_that("ode newind works with dose first", { + expect_equal(s$ni[1], 1L) + expect_equal(s$ni2[1], 1L) + expect_true(all(s$ni[-1] == 2)) + expect_true(all(s$ni2[-1] == 2)) + }) - s2 <- solve(ode.1c, et2, addDosing = TRUE, method = m) + s2 <- solve(ode.1c, et2, addDosing = TRUE, method = m) - test_that("ode newind works with dose first", { - expect_equal(s2$ni[1], 1L) - expect_equal(s2$ni2[1], 1L) - expect_true(all(s2$ni[-1] == 2)) - expect_true(all(s2$ni2[-1] == 2)) - }) + test_that("ode newind works with dose first", { + expect_equal(s2$ni[1], 1L) + expect_equal(s2$ni2[1], 1L) + expect_true(all(s2$ni[-1] == 2)) + expect_true(all(s2$ni2[-1] == 2)) + }) + } } -} +}) diff --git a/tests/testthat/test-nmtest.R b/tests/testthat/test-nmtest.R index ce741c983..ddd6c407e 100644 --- a/tests/testthat/test-nmtest.R +++ b/tests/testthat/test-nmtest.R @@ -1,168 +1,170 @@ -if (!.Call(`_rxode2_isIntel`)) { +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { - ## devtools::load_all() + ## devtools::load_all() - d <- nlmixr2data::nmtest - # internally rxode2 treats lag time evids differently than - # non-lagged events + d <- nlmixr2data::nmtest + # internally rxode2 treats lag time evids differently than + # non-lagged events - # 2 different models to test then - f <- rxode2({ - cl <- 1.1 - v <- 20 - ka <- 1.5 - d/dt(depot) <- -ka*depot - d/dt(central) <- ka*depot - (cl/v)*central - f(central) <- bioav - if (mode == 1) rate(central) <- rat2 - if (mode == 2) dur(central) <- dur2 - cp <- central/(v/1000) - }) + # 2 different models to test then + f <- rxode2({ + cl <- 1.1 + v <- 20 + ka <- 1.5 + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot - (cl/v)*central + f(central) <- bioav + if (mode == 1) rate(central) <- rat2 + if (mode == 2) dur(central) <- dur2 + cp <- central/(v/1000) + }) - fl <- rxode2({ - cl <- 1.1 - v <- 20 - ka <- 1.5 - d/dt(depot) <- -ka*depot - d/dt(central) <- ka*depot - (cl/v)*central - lag(central) <- lagt - f(central) <- bioav - if (mode == 1) rate(central) <- rat2 - if (mode == 2) dur(central) <- dur2 - cp <- central/(v/1000) - }) + fl <- rxode2({ + cl <- 1.1 + v <- 20 + ka <- 1.5 + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot - (cl/v)*central + lag(central) <- lagt + f(central) <- bioav + if (mode == 1) rate(central) <- rat2 + if (mode == 2) dur(central) <- dur2 + cp <- central/(v/1000) + }) - library(ggplot2) + library(ggplot2) - solveEqual <- function(id, plot = p, meth="liblsoda", modifyData = c("none", "dur", "rate"), - addlKeepsCov = TRUE, addlDropSs=TRUE, ss2cancelAllPending=FALSE) { - noLag <- all(d[d$id == id & d$evid != 0,]$lagt == 0) - hasRate <- any(d[d$id == id & d$evid != 0,]$rate != 0) - hasModeledRate <- any(d[d$id == id & d$evid != 0,]$mode == 1) - hasModeledDur <- any(d[d$id == id & d$evid != 0, ]$mode == 2) - hasChangedF <- any(d[d$id == id & d$evid != 0, ]$bioav != 1) - modifyData <- match.arg(modifyData) - d <- d[d$id == id,] - rate <- unlist(as.vector(d[d$evid != 0, "rate"])) - ii0 <- all(d$ii == 0) - oneRate <- (length(rate) == 1L) - dose1 <- all(d[d$evid != 0, ]$cmt == 1) - if (!addlDropSs) { - if (any(d$ss == 2)) { - return() - } - } - if (modifyData == "rate" && hasRate && !hasModeledRate && !hasModeledDur && oneRate && !ii0 && !dose1) { - if (p) message("modified rate to be modeled") - rate <- d[d$evid != 0, "rate", drop=FALSE] - rate <- rate$rate - if (length(rate) == 1) { - d$rat2 <- rate - d$rate <- ifelse(d$rate==0, 0, -1) - d$mode <- 1 + solveEqual <- function(id, plot = p, meth="liblsoda", modifyData = c("none", "dur", "rate"), + addlKeepsCov = TRUE, addlDropSs=TRUE, ss2cancelAllPending=FALSE) { + noLag <- all(d[d$id == id & d$evid != 0,]$lagt == 0) + hasRate <- any(d[d$id == id & d$evid != 0,]$rate != 0) + hasModeledRate <- any(d[d$id == id & d$evid != 0,]$mode == 1) + hasModeledDur <- any(d[d$id == id & d$evid != 0, ]$mode == 2) + hasChangedF <- any(d[d$id == id & d$evid != 0, ]$bioav != 1) + modifyData <- match.arg(modifyData) + d <- d[d$id == id,] + rate <- unlist(as.vector(d[d$evid != 0, "rate"])) + ii0 <- all(d$ii == 0) + oneRate <- (length(rate) == 1L) + dose1 <- all(d[d$evid != 0, ]$cmt == 1) + if (!addlDropSs) { + if (any(d$ss == 2)) { + return() + } } - ## print(etTrans(d, f, addlDropSs=addlDropSs)) - } else if (modifyData == "dur" && hasRate && !hasModeledRate && !hasModeledDur && !hasChangedF && oneRate && !ii0 && !dose1) { - if (p) message("modified dur to be modeled") - rate <- as.numeric(d[d$evid != 0, "rate"]) - amt <- as.numeric(d[d$evid != 0, "amt"]) - if (length(rate) == 1) { - d$dur2 <- amt/rate - d$rate <- ifelse(d$rate==0, 0, -2) - d$mode <- 2 - assign(".d", d, envir=globalenv()) + if (modifyData == "rate" && hasRate && !hasModeledRate && !hasModeledDur && oneRate && !ii0 && !dose1) { + if (p) message("modified rate to be modeled") + rate <- d[d$evid != 0, "rate", drop=FALSE] + rate <- rate$rate + if (length(rate) == 1) { + d$rat2 <- rate + d$rate <- ifelse(d$rate==0, 0, -1) + d$mode <- 1 + } + ## print(etTrans(d, f, addlDropSs=addlDropSs)) + } else if (modifyData == "dur" && hasRate && !hasModeledRate && !hasModeledDur && !hasChangedF && oneRate && !ii0 && !dose1) { + if (p) message("modified dur to be modeled") + rate <- as.numeric(d[d$evid != 0, "rate"]) + amt <- as.numeric(d[d$evid != 0, "amt"]) + if (length(rate) == 1) { + d$dur2 <- amt/rate + d$rate <- ifelse(d$rate==0, 0, -2) + d$mode <- 2 + assign(".d", d, envir=globalenv()) + } + } else if (any(modifyData == c("dur", "rate"))) { + if (p) { + message("skipping because cannot be modified") + print(list(modifyData=modifyData, + noLag=noLag, + hasRate=hasRate, + hasModeledRate=hasModeledRate, + hasModeledDur= hasModeledDur, + hasChangedF=hasChangedF)) + } + return(invisible()) } - } else if (any(modifyData == c("dur", "rate"))) { - if (p) { - message("skipping because cannot be modified") - print(list(modifyData=modifyData, - noLag=noLag, - hasRate=hasRate, - hasModeledRate=hasModeledRate, - hasModeledDur= hasModeledDur, - hasChangedF=hasChangedF)) - } - return(invisible()) - } - if (plot) { - print(ggplot(d, aes(time, cp)) + - geom_point(col="red") + - rxode2::rxTheme() + - ggtitle(paste0("id=", id))) - ## print(etTrans(d, fl)) - s1 <- rxSolve(fl, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs, - ss2cancelAllPending=ss2cancelAllPending) - if (!noLag) { - print(plot(s1, cp) + - geom_point(data=d, aes(x=time, y=cp), col="red") + - ggtitle(paste0("id=", id, "(lag)"))) - } else { - message("================================================== ") - message("f without lag") - message("================================================== ") - s2 <- rxSolve(f, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs, + if (plot) { + print(ggplot(d, aes(time, cp)) + + geom_point(col="red") + + rxode2::rxTheme() + + ggtitle(paste0("id=", id))) + ## print(etTrans(d, fl)) + s1 <- rxSolve(fl, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs, ss2cancelAllPending=ss2cancelAllPending) - return(plot(s1, cp) + - geom_point(data=d, aes(x=time, y=cp), col="red") + - geom_line(data=s2, aes(x=time, y=cp), col="blue", alpha=0.5, linewidth=2) + - ggtitle(paste0("id=", id, "(nolag)"))) - } - ## print(etTrans(d, fl)) - } else { - sub <- 0 - if (id %in% c(410, 411, 409, 415, 709, 510, 610)) { - sub <- 24 - } - if (id %in% c(809, 909, 1009)) { - sub <- 48 - } - if (id %in% 825) { - sub <- 96 - } - if (noLag) { - test_that(paste0("nmtest id:", id, " no alag; method: ", meth, "; modifyData:", modifyData, "; addlDropSs: ", addlDropSs), + if (!noLag) { + print(plot(s1, cp) + + geom_point(data=d, aes(x=time, y=cp), col="red") + + ggtitle(paste0("id=", id, "(lag)"))) + } else { + message("================================================== ") + message("f without lag") + message("================================================== ") + s2 <- rxSolve(f, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs, + ss2cancelAllPending=ss2cancelAllPending) + return(plot(s1, cp) + + geom_point(data=d, aes(x=time, y=cp), col="red") + + geom_line(data=s2, aes(x=time, y=cp), col="blue", alpha=0.5, linewidth=2) + + ggtitle(paste0("id=", id, "(nolag)"))) + } + ## print(etTrans(d, fl)) + } else { + sub <- 0 + if (id %in% c(410, 411, 409, 415, 709, 510, 610)) { + sub <- 24 + } + if (id %in% c(809, 909, 1009)) { + sub <- 48 + } + if (id %in% 825) { + sub <- 96 + } + if (noLag) { + test_that(paste0("nmtest id:", id, " no alag; method: ", meth, "; modifyData:", modifyData, "; addlDropSs: ", addlDropSs), + { + s1 <- rxSolve(f, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs) + expect_equal(s1$cp[s1$time >= sub], + d[d$id == id & d$evid == 0 & d$time >= sub,]$cp, + tolerance = 0.1) + }) + } + test_that(paste0("nmtest id:", id, " alag; method: ", meth, "; modifyData:", modifyData,"; addlDropSs: ", addlDropSs), { - s1 <- rxSolve(f, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs) + s1 <- rxSolve(fl, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs) expect_equal(s1$cp[s1$time >= sub], d[d$id == id & d$evid == 0 & d$time >= sub,]$cp, tolerance = 0.1) }) - } - test_that(paste0("nmtest id:", id, " alag; method: ", meth, "; modifyData:", modifyData,"; addlDropSs: ", addlDropSs), - { - s1 <- rxSolve(fl, d, method=meth, addlKeepsCov = addlKeepsCov, addlDropSs=addlDropSs) - expect_equal(s1$cp[s1$time >= sub], - d[d$id == id & d$evid == 0 & d$time >= sub,]$cp, - tolerance = 0.1) - }) + } } - } - p <- TRUE + p <- TRUE - id <- unique(d$id) + id <- unique(d$id) - p <- FALSE - lapply(id, function(i) { - meths <- c("liblsoda", "lsoda", "dop853") - modDat <- c("none", "rate", "dur") - for (meth in meths) { - for (modifyData in modDat) { - for (addlDropSs in c(TRUE, FALSE)) { - solveEqual(i, meth=meth, modifyData=modifyData, addlDropSs=addlDropSs) + p <- FALSE + lapply(id, function(i) { + meths <- c("liblsoda", "lsoda", "dop853") + modDat <- c("none", "rate", "dur") + for (meth in meths) { + for (modifyData in modDat) { + for (addlDropSs in c(TRUE, FALSE)) { + solveEqual(i, meth=meth, modifyData=modifyData, addlDropSs=addlDropSs) + } } } - } - }) + }) - ## invisible(lapply(unique(d$id), function(i){message(i);solveEqual(i);Sys.sleep(1)})) + ## invisible(lapply(unique(d$id), function(i){message(i);solveEqual(i);Sys.sleep(1)})) - ## need to check id=25 type for infusions too (static, modeled) need - ## to check for steady state when the infusion is still going at the - ## time of steady-state release + ## need to check id=25 type for infusions too (static, modeled) need + ## to check for steady state when the infusion is still going at the + ## time of steady-state release - ## Need to check steady state infusion as well as infusions where ii=dur with lag times + ## Need to check steady state infusion as well as infusions where ii=dur with lag times - ## modeled equivalents of 425, 525 + ## modeled equivalents of 425, 525 -} + } +}) diff --git a/tests/testthat/test-occ.R b/tests/testthat/test-occ.R index cda787ae6..261bdd8e3 100644 --- a/tests/testthat/test-occ.R +++ b/tests/testthat/test-occ.R @@ -1,8 +1,6 @@ rxTest({ test_that("occasions", { - .rxr <- loadNamespace("rxode2") - # Nesting tests mod <- rxode2({ @@ -87,7 +85,7 @@ rxTest({ ) | inv(nu = 10) ) - .ni <- .rxr$nestingInfo_(omega, ev) + .ni <- nestingInfo_(omega, ev) expect_equal(.ni$below, c(eye = 2L, occ = 2L)) expect_equal(.ni$above, c(inv = 2L)) @@ -125,9 +123,7 @@ rxTest({ .ep <- .expandPars(mod, theta, ev, control = rxControl( thetaMat = thetaMat, omega = omega, - nSub = 40, nStud = 3 - ) - ) + nSub = 40, nStud = 3)) expect_equal(length(.ep$KA), 120L) expect_equal(length(unique(.ep$KA)), 3L) @@ -276,7 +272,7 @@ rxTest({ ## Test edge case -- no between or above occasion variability - .ni <- .rxr$nestingInfo_( + .ni <- nestingInfo_( lotri(lotri(eta.Cl ~ 0.1, eta.Ka ~ 0.1) | id(nu = 100)), ev ) diff --git a/tests/testthat/test-omegaCubeConvert.R b/tests/testthat/test-omegaCubeConvert.R index f4ec40c21..4ee8a871c 100644 --- a/tests/testthat/test-omegaCubeConvert.R +++ b/tests/testthat/test-omegaCubeConvert.R @@ -1,12 +1,14 @@ -test_that("test omegaCubeConvert", { - - matLst <- cvPost(10, lotri::lotri(a+b~c(1, 0.25, 1)), 3) - expect_true(inherits(matLst, "list")) - - matCube <- swapMatListWithCube(matLst) - expect_length(dim(matCube), 3L) +rxTest({ + test_that("test omegaCubeConvert", { - matLst2 <- swapMatListWithCube(matCube) + matLst <- cvPost(10, lotri::lotri(a+b~c(1, 0.25, 1)), 3) + expect_true(inherits(matLst, "list")) - expect_identical(matLst2, matLst) + matCube <- swapMatListWithCube(matLst) + expect_length(dim(matCube), 3L) + + matLst2 <- swapMatListWithCube(matCube) + + expect_identical(matLst2, matLst) + }) }) diff --git a/tests/testthat/test-omegaRse.R b/tests/testthat/test-omegaRse.R index 9e90011ef..81202ab68 100644 --- a/tests/testthat/test-omegaRse.R +++ b/tests/testthat/test-omegaRse.R @@ -1,11 +1,13 @@ -test_that("omega RSE function", { +rxTest({ + test_that("omega RSE function", { - tmp <- cvPost(10.2, omega=lotri::lotri(a~0.1), 5) - lst <- omegaListRse(tmp) + tmp <- cvPost(10.2, omega=lotri::lotri(a~0.1), 5) + lst <- omegaListRse(tmp) - expect_equal(mean(unlist(tmp)), as.vector(lst[["mean"]])) - expect_equal(var(unlist(tmp)), as.vector(lst[["var"]])) - expect_equal(sd(unlist(tmp)), as.vector(lst[["sd"]])) - expect_equal(sd(unlist(tmp))/mean(unlist(tmp)), as.vector(lst[["rse"]])) + expect_equal(mean(unlist(tmp)), as.vector(lst[["mean"]])) + expect_equal(var(unlist(tmp)), as.vector(lst[["var"]])) + expect_equal(sd(unlist(tmp)), as.vector(lst[["sd"]])) + expect_equal(sd(unlist(tmp))/mean(unlist(tmp)), as.vector(lst[["rse"]])) + }) }) diff --git a/tests/testthat/test-par-solve.R b/tests/testthat/test-par-solve.R index 867a7d81b..b160610fa 100644 --- a/tests/testthat/test-par-solve.R +++ b/tests/testthat/test-par-solve.R @@ -1,4 +1,5 @@ rxTest({ + expectSimWithout <- function(x) { expect_null(x$thetaMat) expect_null(x$omegaList) @@ -27,8 +28,8 @@ rxTest({ # context(sprintf("Test Parallel/Multi-subject Solve (%s)", meth)) mod <- rxode2({ - d / dt(intestine) <- -a * intestine - d / dt(blood) <- a * intestine - b * blood + d/dt(intestine) <- -a * intestine + d/dt(blood) <- a * intestine - b * blood }) et <- eventTable(time.units = "days") @@ -118,10 +119,10 @@ rxTest({ C2 <- prod(centr, 1 / V2) C3 ~ prod(peri, 1 / V3) CL ~ prod(TCL, exp(eta.Cl)) - d / dt(depot) ~ prod(-KA, depot) - d / dt(centr) ~ sum(prod(KA, depot), -prod(CL, C2), -prod(Q, C2), prod(Q, C3)) - d / dt(peri) ~ sum(prod(Q, C2), -prod(Q, C3)) - d / dt(eff) <- sum(Kin, -prod(Kout, sum(1, -prod(C2, 1 / sum(EC50, C2))), eff)) + d/dt(depot) ~ prod(-KA, depot) + d/dt(centr) ~ sum(prod(KA, depot), -prod(CL, C2), -prod(Q, C2), prod(Q, C3)) + d/dt(peri) ~ sum(prod(Q, C2), -prod(Q, C3)) + d/dt(eff) <- sum(Kin, -prod(Kout, sum(1, -prod(C2, 1 / sum(EC50, C2))), eff)) e1 <- err1 e2 <- err2 resp <- sum(eff, e1) @@ -159,10 +160,10 @@ rxTest({ C2 <- centr / V2 C3 ~ peri / V3 CL ~ TCL * exp(eta.Cl) - d / dt(depot) ~ -KA * depot - d / dt(centr) ~ KA * depot - CL * C2 - Q * C2 + Q * C3 - d / dt(peri) ~ Q * C2 - Q * C3 - d / dt(eff) <- Kin - Kout * (1 - C2 / (EC50 + C2)) * eff + d/dt(depot) ~ -KA * depot + d/dt(centr) ~ KA * depot - CL * C2 - Q * C2 + Q * C3 + d/dt(peri) ~ Q * C2 - Q * C3 + d/dt(eff) <- Kin - Kout * (1 - C2 / (EC50 + C2)) * eff eff(0) <- 1000 e1 <- err1 e2 <- err2 diff --git a/tests/testthat/test-parsing.R b/tests/testthat/test-parsing.R index 6075662f3..629043e74 100644 --- a/tests/testthat/test-parsing.R +++ b/tests/testthat/test-parsing.R @@ -359,6 +359,12 @@ mu = 1+bad ## nonstiff; 10 moderately stiff; 1000 stiff "d/dt(x)=(THETA[1]+ETA[1])*x\ndf(x)/dy(THETA[1]) = 1\ndf(x)/dy(ETA[1]) = 1\nmtime(z)=d/dt(x)+3" ) + withr::with_options(list("rxode2.syntax.require.ode.first" = FALSE), { + goodParse( + "verbose output", + "d/dt(x) = -k*x" + ) + }) goodParse( "functional initialization ok", "x(0) = y + 3\nd/dt(x) =-3*z" @@ -419,9 +425,10 @@ mu = 1+bad ## nonstiff; 10 moderately stiff; 1000 stiff d/dt(ce) = keo*(cp-ce) effect = E0 - Emax*(Ce^gamma)/((Ce^gamma)+(Ec50^gamma));") - badParse( - "Still cannot take undefined compartments", - "popCl <- 1 + withr::with_options(list("rxode2.syntax.require.ode.first" = TRUE), { + badParse( + "Still cannot take undefined compartments", + "popCl <- 1 popV <- 20 popKa <- 1 popVp <- 10 @@ -463,7 +470,8 @@ mu = 1+bad ## nonstiff; 10 moderately stiff; 1000 stiff cp <- linCmt() d/dt(ce) = keo*(cp-ce) effect = E0 - Emax*(Ce^gamma)/((Ce^gamma)+(Ec50^gamma));" - ) + ) + }) badParse("cmt(depot) doesn't work with linCmt()", "popCl <- 1 cmt(depot) @@ -1030,6 +1038,7 @@ mu = 1+bad ## nonstiff; 10 moderately stiff; 1000 stiff d/dt(ce) = keo*(cp-ce) effect = E0 - Emax*(Ce^gamma)/((Ce^gamma)+(Ec50^gamma));") + withr::with_options(list("rxode2.syntax.require.ode.first" = TRUE), { badParse( "Still cannot take undefined compartments", "popCl <- 1 @@ -1070,11 +1079,11 @@ mu = 1+bad ## nonstiff; 10 moderately stiff; 1000 stiff alag(central) <- popLagCentral * exp(bsvLagCentral) rate(central) <- popRateCentral * exp(bsvRateCentral) dur(central) <- popDurCentral * exp(bsvDurCentral) - dur(matt) <- 3 + dur(matta) <- 3 # undefined compartment cp <- linCmt() d/dt(ce) = keo*(cp-ce) effect = E0 - Emax*(Ce^gamma)/((Ce^gamma)+(Ec50^gamma));" - ) + )}) badParse("cmt(depot) doesn't work with linCmt()", "popCl <- 1 cmt(depot) @@ -1351,4 +1360,9 @@ mu = 1+bad ## nonstiff; 10 moderately stiff; 1000 stiff } }) + test_that("cmt/locf interaction", { + expect_equal(rxNorm(rxModelVars("cmt(a);\nlocf(b);d/dt(a)=b*kel")), + "cmt(a);\nlocf(b);\nd/dt(a)=b*kel;\n") + }) + }) diff --git a/tests/testthat/test-pheno.R b/tests/testthat/test-pheno.R index 83db01918..a222257c2 100644 --- a/tests/testthat/test-pheno.R +++ b/tests/testthat/test-pheno.R @@ -1,8 +1,10 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("label replacement", { - .pheno <- c("function() {", " # Pheno with covariance", " ini({", " tcl <- log(0.008) # typical value of clearance", " tv <- log(0.6) # typical value of volume", " ## var(eta.cl)", " eta.cl + eta.v ~ c(1,", " 0.01, 1) ## cov(eta.cl, eta.v), var(eta.v)", " # interindividual variability on clearance and volume", " add.err <- 0.1 # residual variability", " })", " model({", " cl <- exp(tcl + eta.cl) # individual value of clearance", " v <- exp(tv + eta.v) # individual value of volume", " ke <- cl / v # elimination rate constant", " d/dt(A1) = - ke * A1 # model differential equation", " cp = A1 / v # concentration in plasma", " cp ~ add(add.err) # define error model", " })", "}") - suppressMessages( - expect_error(.rxReplaceCommentWithLabel(.pheno), NA) - ) - }) -} +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("label replacement", { + .pheno <- c("function() {", " # Pheno with covariance", " ini({", " tcl <- log(0.008) # typical value of clearance", " tv <- log(0.6) # typical value of volume", " ## var(eta.cl)", " eta.cl + eta.v ~ c(1,", " 0.01, 1) ## cov(eta.cl, eta.v), var(eta.v)", " # interindividual variability on clearance and volume", " add.err <- 0.1 # residual variability", " })", " model({", " cl <- exp(tcl + eta.cl) # individual value of clearance", " v <- exp(tv + eta.v) # individual value of volume", " ke <- cl / v # elimination rate constant", " d/dt(A1) = - ke * A1 # model differential equation", " cp = A1 / v # concentration in plasma", " cp ~ add(add.err) # define error model", " })", "}") + suppressMessages( + expect_error(.rxReplaceCommentWithLabel(.pheno), NA) + ) + }) + } +}) diff --git a/tests/testthat/test-phi.R b/tests/testthat/test-phi.R index ea40e15c7..ce8c85591 100644 --- a/tests/testthat/test-phi.R +++ b/tests/testthat/test-phi.R @@ -1,106 +1,104 @@ rxTest({ - rxTest({ - test_that("phi/pnorm/qnorm", { - expect_equal(phi(1:3), pnorm(1:3)) - expect_equal(phi(as.double(1:3)), pnorm(as.double(1:3))) - - o <- rxode2({ - o <- phi(a) - }) - - expect_equal( - rxSolve(o, data.frame(a = 1:3), et(0))$o, - pnorm(as.double(1:3)) - ) - - o <- rxode2({ - o <- pnorm(a) - }) - - expect_equal( - rxSolve(o, data.frame(a = 1:3), et(0))$o, - pnorm(as.double(1:3)) - ) - - o <- rxode2({ - o <- pnorm(a, 0.5) - }) - - expect_equal( - rxSolve(o, data.frame(a = 1:3), et(0))$o, - pnorm(as.double(1:3), 0.5) - ) - - o <- rxode2({ - o <- pnorm(a, 0.5, 2) - }) - - expect_equal( - rxSolve(o, data.frame(a = 1:3), et(0))$o, - pnorm(as.double(1:3), 0.5, 2) - ) - - suppressMessages(expect_error(rxode2({ - o <- pnorm() - }))) - - suppressMessages(expect_error(rxode2({ - o <- pnorm(a, b, c, d) - }))) - - o <- rxode2({ - o <- qnorm(a) - }) - - expect_equal( - rxSolve(o, data.frame(a = 1:3), et(0))$o, - suppressWarnings(qnorm(as.double(1:3))) - ) - - o <- rxode2({ - o <- qnorm(a, 0.5) - }) - - expect_equal( - rxSolve(o, data.frame(a = 1:3), et(0))$o, - suppressWarnings(qnorm(as.double(1:3), 0.5)) - ) - - o <- rxode2({ - o <- qnorm(a, 0.5, 2) - }) - - expect_equal( - rxSolve(o, data.frame(a = 1:3), et(0))$o, - suppressWarnings(qnorm(as.double(1:3), 0.5, 2)) - ) - - suppressMessages(expect_error(rxode2({ - o <- qnorm() - }))) - - suppressMessages(expect_error(rxode2({ - o <- qnorm(a, b, c, d) - }))) - - m <- rxode2({ - o <- pnorm(a) - }) - - skip_if_not_installed("units") - expect_error(rxS(m), NA) - - m <- rxode2({ - o <- pnorm(a, b) - }) - - expect_error(rxS(m), NA) - - m <- rxode2({ - o <- pnorm(a, b, c) - }) - - expect_error(rxS(m), NA) + test_that("phi/pnorm/qnorm", { + expect_equal(phi(1:3), pnorm(1:3)) + expect_equal(phi(as.double(1:3)), pnorm(as.double(1:3))) + + o <- rxode2({ + o <- phi(a) }) + + expect_equal( + rxSolve(o, data.frame(a = 1:3), et(0))$o, + pnorm(as.double(1:3)) + ) + + o <- rxode2({ + o <- pnorm(a) + }) + + expect_equal( + rxSolve(o, data.frame(a = 1:3), et(0))$o, + pnorm(as.double(1:3)) + ) + + o <- rxode2({ + o <- pnorm(a, 0.5) + }) + + expect_equal( + rxSolve(o, data.frame(a = 1:3), et(0))$o, + pnorm(as.double(1:3), 0.5) + ) + + o <- rxode2({ + o <- pnorm(a, 0.5, 2) + }) + + expect_equal( + rxSolve(o, data.frame(a = 1:3), et(0))$o, + pnorm(as.double(1:3), 0.5, 2) + ) + + suppressMessages(expect_error(rxode2({ + o <- pnorm() + }))) + + suppressMessages(expect_error(rxode2({ + o <- pnorm(a, b, c, d) + }))) + + o <- rxode2({ + o <- qnorm(a) + }) + + expect_equal( + rxSolve(o, data.frame(a = 1:3), et(0))$o, + suppressWarnings(qnorm(as.double(1:3))) + ) + + o <- rxode2({ + o <- qnorm(a, 0.5) + }) + + expect_equal( + rxSolve(o, data.frame(a = 1:3), et(0))$o, + suppressWarnings(qnorm(as.double(1:3), 0.5)) + ) + + o <- rxode2({ + o <- qnorm(a, 0.5, 2) + }) + + expect_equal( + rxSolve(o, data.frame(a = 1:3), et(0))$o, + suppressWarnings(qnorm(as.double(1:3), 0.5, 2)) + ) + + suppressMessages(expect_error(rxode2({ + o <- qnorm() + }))) + + suppressMessages(expect_error(rxode2({ + o <- qnorm(a, b, c, d) + }))) + + m <- rxode2({ + o <- pnorm(a) + }) + + skip_if_not_installed("units") + expect_error(rxS(m), NA) + + m <- rxode2({ + o <- pnorm(a, b) + }) + + expect_error(rxS(m), NA) + + m <- rxode2({ + o <- pnorm(a, b, c) + }) + + expect_error(rxS(m), NA) }) }) diff --git a/tests/testthat/test-piping-ini.R b/tests/testthat/test-piping-ini.R index 34a1e1081..42d29f7f0 100644 --- a/tests/testthat/test-piping-ini.R +++ b/tests/testthat/test-piping-ini.R @@ -1,790 +1,923 @@ -if (!.Call(`_rxode2_isIntel`)) { - test_that("back transformation piping", { +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + test_that("back transformation piping", { + + mod1 <- function() { + ini({ + # central + KA <- 2.94E-01 + backTransform("exp") + CL <- 1.86E+01 + V2 <- 4.02E+01 + # peripheral + Q <- 1.05E+01 + V3 <- 2.97E+02 + # effects + Kin <- 1 + Kout <- 1 + EC50 <- 200 + }) + model({ + C2 <- centr/V2 + C3 <- peri/V3 + d/dt(depot) <- -KA*depot + d/dt(centr) <- KA*depot - CL*C2 - Q*C2 + Q*C3 + d/dt(peri) <- Q*C2 - Q*C3 + eff(0) <- 1 + d/dt(eff) <- Kin - Kout*(1-C2/(EC50+C2))*eff + }) + } + + ui <- rxode(mod1) + + expect_equal(ui$iniDf$backTransform[ui$iniDf$name == "KA"], "exp") + + p1 <- ui %>% + ini( + KA <- backTransform("log") + ) - mod1 <- function() { - ini({ - # central - KA <- 2.94E-01 - backTransform("exp") - CL <- 1.86E+01 - V2 <- 4.02E+01 - # peripheral - Q <- 1.05E+01 - V3 <- 2.97E+02 - # effects - Kin <- 1 - Kout <- 1 - EC50 <- 200 - }) - model({ - C2 <- centr/V2 - C3 <- peri/V3 - d/dt(depot) <- -KA*depot - d/dt(centr) <- KA*depot - CL*C2 - Q*C2 + Q*C3 - d/dt(peri) <- Q*C2 - Q*C3 - eff(0) <- 1 - d/dt(eff) <- Kin - Kout*(1-C2/(EC50+C2))*eff - }) - } + expect_equal(p1$iniDf$backTransform[ui$iniDf$name == "KA"], "log") - ui <- rxode(mod1) + p2 <-ui %>% + ini( + KA <- backTransform(log) + ) - expect_equal(ui$iniDf$backTransform[ui$iniDf$name == "KA"], "exp") + expect_equal(p2$iniDf$backTransform[ui$iniDf$name == "KA"], "log") - p1 <- ui %>% - ini( - KA <- backTransform("log") - ) + p3 <- ui |> + ini(KA <- backTransform(NULL)) - expect_equal(p1$iniDf$backTransform[ui$iniDf$name == "KA"], "log") + expect_equal(p3$iniDf$backTransform[ui$iniDf$name == "KA"], NA_character_) - p2 <-ui %>% - ini( - KA <- backTransform(log) - ) + expect_error(ui |> + ini(KA <- backTransform(matt)), "matt") - expect_equal(p2$iniDf$backTransform[ui$iniDf$name == "KA"], "log") + }) - p3 <- ui |> - ini(KA <- backTransform(NULL)) + test_that("piping with ini can update labels (rxode2/issues#351)", { + mod <- function() { + ini({ + a <- 1 + label("foo") + addSd <- 2 + }) + model({ + b <- a + b ~ add(addSd) + }) + } + ui <- rxode2(mod) + expect_equal(ui$iniDf$label[ui$iniDf$name == "a"], "foo") + newLabelUi <- ini(ui, a = label("bar")) + expect_equal(newLabelUi$iniDf$label[newLabelUi$iniDf$name == "a"], "bar") + }) - expect_equal(p3$iniDf$backTransform[ui$iniDf$name == "KA"], NA_character_) + test_that("piping with ini can remove labels (#627)", { + + mod <- function() { + ini({ + a <- 1 + label("foo") + addSd <- 2 + }) + model({ + b <- a + b ~ add(addSd) + }) + } + ui <- rxode2(mod) + expect_equal(ui$iniDf$label[ui$iniDf$name == "a"], "foo") + newLabelUi <- ini(ui, a = label(NULL)) + expect_equal(newLabelUi$iniDf$label[ui$iniDf$name == "a"], NA_character_) + }) - expect_error(ui |> - ini(KA <- backTransform(matt)), "matt") + test_that("piping with ini gives an error pointing the user to use label for character rhs (rxode2/issues#351)", { + mod <- function() { + ini({ + a <- 1 + label("foo") + addSd <- 2 + }) + model({ + b <- a + b ~ add(addSd) + }) + } + ui <- rxode2(mod) + expect_error( + ini(ui, a = "bar"), + regexp = "to assign a new label, use 'a <- label(\"bar\")'", + fixed = TRUE + ) + }) - }) + test_that("piping with ini can update labels (rxode2/issues#351)", { + mod <- function() { + ini({ + a <- 1 + label("foo") + addSd <- 2 + }) + model({ + b <- a + b ~ add(addSd) + }) + } + ui <- rxode2(mod) + expect_equal(ui$iniDf$label[ui$iniDf$name == "a"], "foo") + newLabelUi <- ini(ui, a = label("bar")) + expect_equal(newLabelUi$iniDf$label[newLabelUi$iniDf$name == "a"], "bar") + }) - test_that("piping with ini can update labels (rxode2/issues#351)", { - mod <- function() { - ini({ - a <- 1 - label("foo") - addSd <- 2 - }) - model({ - b <- a - b ~ add(addSd) - }) - } - ui <- rxode2(mod) - expect_equal(ui$iniDf$label[ui$iniDf$name == "a"], "foo") - newLabelUi <- ini(ui, a = label("bar")) - expect_equal(newLabelUi$iniDf$label[newLabelUi$iniDf$name == "a"], "bar") - }) + test_that("piping with ini gives an error pointing the user to use label for character rhs (rxode2/issues#351)", { + mod <- function() { + ini({ + a <- 1 + label("foo") + addSd <- 2 + }) + model({ + b <- a + b ~ add(addSd) + }) + } + ui <- rxode2(mod) + expect_error( + ini(ui, a = "bar"), + regexp = "to assign a new label, use 'a <- label(\"bar\")'", + fixed = TRUE + ) + }) - test_that("piping with ini can remove labels (#627)", { - mod <- function() { - ini({ - a <- 1 - label("foo") - addSd <- 2 - }) - model({ - b <- a - b ~ add(addSd) - }) - } - ui <- rxode2(mod) - expect_equal(ui$iniDf$label[ui$iniDf$name == "a"], "foo") - newLabelUi <- ini(ui, a = label(NULL)) - expect_equal(newLabelUi$iniDf$label[ui$iniDf$name == "a"], NA_character_) - }) + test_that(".iniSimplifyFixUnfix", { + expect_equal( + .iniSimplifyFixUnfix(str2lang("fix")), + as.name("fix") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("fixed")), + as.name("fix") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("FIX")), + as.name("fix") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("FIXED")), + as.name("fix") + ) - test_that("piping with ini gives an error pointing the user to use label for character rhs (rxode2/issues#351)", { - mod <- function() { - ini({ - a <- 1 - label("foo") - addSd <- 2 - }) - model({ - b <- a - b ~ add(addSd) - }) - } - ui <- rxode2(mod) - expect_error( - ini(ui, a = "bar"), - regexp = "to assign a new label, use 'a <- label(\"bar\")'", - fixed = TRUE - ) - }) + expect_equal( + .iniSimplifyFixUnfix(str2lang("unfix")), + as.name("unfix") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("unfixed")), + as.name("unfix") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("UNFIX")), + as.name("unfix") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("UNFIXED")), + as.name("unfix") + ) - test_that("piping with ini can update labels (rxode2/issues#351)", { - mod <- function() { - ini({ - a <- 1 - label("foo") - addSd <- 2 - }) - model({ - b <- a - b ~ add(addSd) - }) - } - ui <- rxode2(mod) - expect_equal(ui$iniDf$label[ui$iniDf$name == "a"], "foo") - newLabelUi <- ini(ui, a = label("bar")) - expect_equal(newLabelUi$iniDf$label[newLabelUi$iniDf$name == "a"], "bar") - }) + expect_equal( + .iniSimplifyFixUnfix(str2lang("FIXED(a)")), + str2lang("fix(a)") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("c <- FIXED(a+b)")), + str2lang("c <- fix(a + b)") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("c <- UNFIXED(a+b)")), + str2lang("c <- unfix(a + b)") + ) + expect_equal( + .iniSimplifyFixUnfix(str2lang("c <- NULL")), + str2lang("c <- NULL") + ) + }) - test_that("piping with ini gives an error pointing the user to use label for character rhs (rxode2/issues#351)", { - mod <- function() { - ini({ - a <- 1 - label("foo") - addSd <- 2 - }) - model({ - b <- a - b ~ add(addSd) - }) - } - ui <- rxode2(mod) - expect_error( - ini(ui, a = "bar"), - regexp = "to assign a new label, use 'a <- label(\"bar\")'", - fixed = TRUE - ) - }) + test_that(".iniSimplifyAssignArrow", { + expect_equal( + .iniSimplifyAssignArrow(str2lang("a <- b")), + str2lang("a <- b") + ) + expect_equal( + .iniSimplifyAssignArrow(str2lang("a = b")), + str2lang("a <- b") + ) + # non-assignment equal signs are not modified + expect_equal( + .iniSimplifyAssignArrow(str2lang("a = b(c=d)")), + str2lang("a <- b(c=d)") + ) + }) + test_that("piping with ini can update reorder parameters (rxode2/issues#352)", { + + mod <- function() { + ini({ + a <- 1 + b <- 2 + c <- 3 + addSd <- 2 + }) + model({ + b <- a + b*log(c) + b ~ add(addSd) + }) + } + + ui <- rxode2(mod) + + # No modification + expect_equal(ui$iniDf$name, c("a", "b", "c", "addSd")) + # b to the top by number + expect_equal(suppressMessages(ini(ui, b <- 1, append = 0))$iniDf$name, c("b", "a", "c", "addSd")) + # b to the top by logical + expect_equal(suppressMessages(ini(ui, b <- 1, append = FALSE))$iniDf$name, c("b", "a", "c", "addSd")) + # b to the bottom by number + expect_equal(suppressMessages(ini(ui, b <- 1, append = Inf))$iniDf$name, c("a", "c", "addSd", "b")) + # b to the bottom by logical + expect_equal(suppressMessages(ini(ui, b <- 1, append = TRUE))$iniDf$name, c("a", "c", "addSd", "b")) + # b to the bottom by name + expect_equal(suppressMessages(ini(ui, b <- 1, append = "addSd"))$iniDf$name, c("a", "c", "addSd", "b")) + + expect_equal(suppressMessages(ini(ui, b <- 1, append = addSd))$iniDf$name, c("a", "c", "addSd", "b")) + + # b after c + expect_equal(suppressMessages(ini(ui, b <- 1, append = "c"))$iniDf$name, c("a", "c", "b", "addSd")) + # a and b after c; counter-intuitive: the order of a and b are reversed + expect_equal(suppressMessages(ini(ui, a <- 1, b <- 1, append = "c"))$iniDf$name, c("c", "b", "a", "addSd")) + # b to b, warn and no change + expect_warning( + expect_equal(suppressMessages(ini(ui, b <- 1, append = "b"))$iniDf$name, c("a", "b", "c", "addSd")), + regexp = "parameter 'b' set to be moved after itself, no change in order made" + ) - test_that(".iniSimplifyFixUnfix", { - expect_equal( - .iniSimplifyFixUnfix(str2lang("fix")), - as.name("fix") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("fixed")), - as.name("fix") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("FIX")), - as.name("fix") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("FIXED")), - as.name("fix") - ) + expect_error( + ini(ui, b <- 1, append = d/dt(fun)), + "append") - expect_equal( - .iniSimplifyFixUnfix(str2lang("unfix")), - as.name("unfix") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("unfixed")), - as.name("unfix") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("UNFIX")), - as.name("unfix") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("UNFIXED")), - as.name("unfix") - ) + # Invalid parameter is correctly caught + expect_error( + ini(ui, b <- 1, append = "foo"), + "append" + ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("FIXED(a)")), - str2lang("fix(a)") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("c <- FIXED(a+b)")), - str2lang("c <- fix(a + b)") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("c <- UNFIXED(a+b)")), - str2lang("c <- unfix(a + b)") - ) - expect_equal( - .iniSimplifyFixUnfix(str2lang("c <- NULL")), - str2lang("c <- NULL") - ) - }) + }) - test_that(".iniSimplifyAssignArrow", { - expect_equal( - .iniSimplifyAssignArrow(str2lang("a <- b")), - str2lang("a <- b") - ) - expect_equal( - .iniSimplifyAssignArrow(str2lang("a = b")), - str2lang("a <- b") - ) - # non-assignment equal signs are not modified - expect_equal( - .iniSimplifyAssignArrow(str2lang("a = b(c=d)")), - str2lang("a <- b(c=d)") - ) - }) + test_that(".iniAddCovarianceBetweenTwoEtaValues", { + # Promote a covariate to a correlated eta + + mod <- function() { + ini({ + a <- 1 + b <- 2 + c <- 3 + d ~ 1 + h ~ 2 + addSd <- 2 + }) + model({ + b <- a + b*log(c) + f <- a + d + e + i <- j + h + b ~ add(addSd) + }) + } - test_that("piping with ini can update reorder parameters (rxode2/issues#352)", { + suppressMessages( + expect_message( + ini(mod, d + e ~ c(1, 0.5, 3)), + regexp = "promote `e` to between subject variability" + ) + ) - mod <- function() { - ini({ - a <- 1 - b <- 2 - c <- 3 - addSd <- 2 - }) - model({ - b <- a + b*log(c) - b ~ add(addSd) - }) - } + suppressMessages( + expect_message( + ini(mod, d ~ 1, e ~ c(0.5, 3)), + regexp = "promote `e` to between subject variability" + ) + ) - ui <- rxode2(mod) - - # No modification - expect_equal(ui$iniDf$name, c("a", "b", "c", "addSd")) - # b to the top by number - expect_equal(suppressMessages(ini(ui, b <- 1, append = 0))$iniDf$name, c("b", "a", "c", "addSd")) - # b to the top by logical - expect_equal(suppressMessages(ini(ui, b <- 1, append = FALSE))$iniDf$name, c("b", "a", "c", "addSd")) - # b to the bottom by number - expect_equal(suppressMessages(ini(ui, b <- 1, append = Inf))$iniDf$name, c("a", "c", "addSd", "b")) - # b to the bottom by logical - expect_equal(suppressMessages(ini(ui, b <- 1, append = TRUE))$iniDf$name, c("a", "c", "addSd", "b")) - # b to the bottom by name - expect_equal(suppressMessages(ini(ui, b <- 1, append = "addSd"))$iniDf$name, c("a", "c", "addSd", "b")) - - expect_equal(suppressMessages(ini(ui, b <- 1, append = addSd))$iniDf$name, c("a", "c", "addSd", "b")) - - # b after c - expect_equal(suppressMessages(ini(ui, b <- 1, append = "c"))$iniDf$name, c("a", "c", "b", "addSd")) - # a and b after c; counter-intuitive: the order of a and b are reversed - expect_equal(suppressMessages(ini(ui, a <- 1, b <- 1, append = "c"))$iniDf$name, c("c", "b", "a", "addSd")) - # b to b, warn and no change - expect_warning( - expect_equal(suppressMessages(ini(ui, b <- 1, append = "b"))$iniDf$name, c("a", "b", "c", "addSd")), - regexp = "parameter 'b' set to be moved after itself, no change in order made" - ) + suppressMessages( + expect_message( + ini(mod, { + d ~ 1 + e ~ c(0.5, 3)}) + )) - expect_error( - ini(ui, b <- 1, append = d/dt(fun)), - "append") + # Non-existent correlated eta + suppressMessages( + expect_error( + ini(mod, d + g ~ c(1, 0.5, 3)), + regexp = "cannot find parameter 'g'" + ) + ) - # Invalid parameter is correctly caught - expect_error( - ini(ui, b <- 1, append = "foo"), - "append" - ) + suppressMessages( + expect_error( + ini(mod, d ~ 1, g ~ c(0.5, 3)), + regexp = "cannot find parameter 'g'" + ) + ) - }) - test_that(".iniAddCovarianceBetweenTwoEtaValues", { - # Promote a covariate to a correlated eta - mod <- function() { - ini({ - a <- 1 - b <- 2 - c <- 3 - d ~ 1 - h ~ 2 - addSd <- 2 - }) - model({ - b <- a + b*log(c) - f <- a + d + e - i <- j + h - b ~ add(addSd) - }) - } - suppressMessages( - expect_message( - ini(mod, d + e ~ c(1, 0.5, 3)), - regexp = "promote `e` to between subject variability" + # Update eta order + suppressMessages( + expect_equal( + ini(mod, h + d ~ c(1, 0.5, 3))$iniDf$name, + c("a", "b", "c", "addSd", "h", "d", "(h,d)") + ) + ) + + suppressMessages( + expect_equal( + ini(mod, h ~ 1, d ~ c(0.5, 3))$iniDf$name, + c("a", "b", "c", "addSd", "h", "d", "(h,d)") + ) ) - ) - # Non-existent correlated eta - suppressMessages( + }) + + test_that(".iniHandleLabel", { + mod <- function() { + ini({ + a <- 1 + b <- 2 + c <- 3 + d ~ 1 + h ~ 2 + addSd <- 2 + }) + model({ + b <- a + b*log(c) + f <- a + d + e + i <- j + h + b ~ add(addSd) + }) + } + + # non-existent parameter expect_error( - ini(mod, d + g ~ c(1, 0.5, 3)), - regexp = "cannot find parameter 'g'" + ini(mod, q = label("foo")), + regexp = "cannot find parameter 'q'" ) - ) - # Update eta order - suppressMessages( - expect_equal( - ini(mod, h + d ~ c(1, 0.5, 3))$iniDf$name, - c("a", "b", "c", "addSd", "h", "d", "(h,d)") + # invalid label value + expect_error( + ini(mod, a = label(5)), + regexp = "the new label for 'a' must be a character string" ) - ) - }) + }) - test_that(".iniHandleLabel", { - mod <- function() { - ini({ - a <- 1 - b <- 2 - c <- 3 - d ~ 1 - h ~ 2 - addSd <- 2 - }) - model({ - b <- a + b*log(c) - f <- a + d + e - i <- j + h - b ~ add(addSd) - }) - } + test_that(".iniHandleAppend", { + mod <- function() { + ini({ + a <- 1 + b <- 2 + c <- 3 + d ~ 1 + h ~ 2 + addSd <- 2 + }) + model({ + b <- a + b*log(c) + f <- a + d + e + i <- j + h + b ~ add(addSd) + }) + } - # non-existent parameter - expect_error( - ini(mod, q = label("foo")), - regexp = "cannot find parameter 'q'" - ) - # invalid label value - expect_error( - ini(mod, a = label(5)), - regexp = "the new label for 'a' must be a character string" - ) - }) + expect_error( + ini(mod, a <- 1, append=factor("A")), + regexp = "'append' must be NULL, logical, numeric, or character/expression of variable in model" + ) + expect_error( + ini(mod, q <- 1, append=0), + regexp = "cannot find parameter 'q'" + ) + # Non-theta parameters cannot be moved + expect_error( + ini(mod, h ~ 1, append=0), + regexp = "only theta parameters can be moved" + ) + }) - test_that(".iniHandleAppend", { - mod <- function() { - ini({ - a <- 1 - b <- 2 - c <- 3 - d ~ 1 - h ~ 2 - addSd <- 2 - }) - model({ - b <- a + b*log(c) - f <- a + d + e - i <- j + h - b ~ add(addSd) - }) - } + test_that("ini tests for different types of expressions", { - expect_error( - ini(mod, a <- 1, append=factor("A")), - regexp = "'append' must be NULL, logical, numeric, or character/expression of variable in model" - ) - expect_error( - ini(mod, q <- 1, append=0), - regexp = "cannot find parameter 'q'" - ) - # Non-theta parameters cannot be moved - expect_error( - ini(mod, h ~ 1, append=0), - regexp = "only theta parameters can be moved" - ) - }) + mod <- function() { + ini({ + a <- 1 + b <- 2 + c <- 3 + d ~ 1 + h ~ 2 + addSd <- 2 + }) + model({ + b <- a + b*log(c) + f <- a + d + e + i <- j + h + b ~ add(addSd) + }) + } - test_that("ini tests for different types of expressions", { + expect_error(mod %>% ini("h~3"), NA) - mod <- function() { - ini({ - a <- 1 - b <- 2 - c <- 3 - d ~ 1 - h ~ 2 - addSd <- 2 - }) - model({ - b <- a + b*log(c) - f <- a + d + e - i <- j + h - b ~ add(addSd) - }) - } + expect_error(mod %>% ini("h~3;4*")) - expect_error(mod %>% ini("h~3"), NA) + expect_error(mod %>% ini(factor("A"))) - expect_error(mod %>% ini("h~3;4*")) + }) - expect_error(mod %>% ini(factor("A"))) + test_that("zeroRe", { + modOmegaSigma <- function() { + ini({ + a <- 1; label("foo") #nolint + iiva ~ 3 + addSd <- 2 + }) + model({ + b <- a + iiva + b ~ add(addSd) + }) + } + modOmega <- function() { + ini({ + a <- 1; label("foo") # nolint + iiva ~ 3 + }) + model({ + b <- a + iiva + }) + } + modSigma <- function() { + ini({ + a <- 1; label("foo") # nolint + addSd <- 2 + }) + model({ + b <- a + b ~ add(addSd) + }) + } + modSigmaBound <- function() { + ini({ + a <- 1; label("foo") # nolint + addSd <- c(1, 2) + }) + model({ + b <- a + b ~ add(addSd) + }) + } + modNone <- function() { + ini({ + a <- 1; label("foo") # nolint + }) + model({ + b <- a + }) + } + uiOmegaSigma <- rxode2(modOmegaSigma) + uiOmega <- rxode2(modOmega) + uiSigma <- rxode2(modSigma) + uiSigmaBound <- rxode2(modSigmaBound) + uiNone <- rxode2(modNone) + + expect_silent( + suppressMessages( + newMod <- zeroRe(modOmegaSigma, which = c("omega", "sigma")) + ) + ) + expect_silent( + suppressMessages( + newUi <- zeroRe(uiOmegaSigma, which = c("omega", "sigma")) + ) + ) + expect_equal(newMod$iniDf, newUi$iniDf) + # detect change + expect_equal(uiOmegaSigma$iniDf$est, c(1, 2, 3)) + expect_equal(newMod$iniDf$est, c(1, 0, 0)) - }) + # Confirm that you can simulate from the model + suppressMessages( + expect_equal( + rxSolve(newMod, events = data.frame(TIME = 0:2))$b, + rep(1, 3) + ) + ) - test_that("zeroRe", { - modOmegaSigma <- function() { - ini({ - a <- 1; label("foo") #nolint - iiva ~ 3 - addSd <- 2 - }) - model({ - b <- a + iiva - b ~ add(addSd) - }) - } - modOmega <- function() { - ini({ - a <- 1; label("foo") # nolint - iiva ~ 3 - }) - model({ - b <- a + iiva - }) - } - modSigma <- function() { - ini({ - a <- 1; label("foo") # nolint - addSd <- 2 - }) - model({ - b <- a - b ~ add(addSd) - }) - } - modSigmaBound <- function() { - ini({ - a <- 1; label("foo") # nolint - addSd <- c(1, 2) - }) - model({ - b <- a - b ~ add(addSd) - }) - } - modNone <- function() { - ini({ - a <- 1; label("foo") # nolint - }) - model({ - b <- a - }) - } - uiOmegaSigma <- rxode2(modOmegaSigma) - uiOmega <- rxode2(modOmega) - uiSigma <- rxode2(modSigma) - uiSigmaBound <- rxode2(modSigmaBound) - uiNone <- rxode2(modNone) + # Confirm that the `fix` flag is respected + expect_silent( + suppressMessages( + newUiNoFix <- zeroRe(uiOmegaSigma, which = c("omega", "sigma"), fix = FALSE) + ) + ) + # detect change + expect_equal(uiOmegaSigma$iniDf$fix, rep(FALSE, 3)) + expect_equal(newUi$iniDf$fix, c(FALSE, TRUE, TRUE)) + expect_equal(newUiNoFix$iniDf$fix, rep(FALSE, 3)) - expect_silent( suppressMessages( - newMod <- zeroRe(modOmegaSigma, which = c("omega", "sigma")) + expect_warning( + newMod <- zeroRe(modOmega, which = c("omega", "sigma")), + regexp = "No sigma parameters in the model" + ) ) - ) - expect_silent( suppressMessages( - newUi <- zeroRe(uiOmegaSigma, which = c("omega", "sigma")) + expect_warning( + newUi <- zeroRe(uiOmega, which = c("omega", "sigma")), + regexp = "No sigma parameters in the model" + ) ) - ) - expect_equal(newMod$iniDf, newUi$iniDf) - # detect change - expect_equal(uiOmegaSigma$iniDf$est, c(1, 2, 3)) - expect_equal(newMod$iniDf$est, c(1, 0, 0)) + expect_equal(newMod$iniDf, newUi$iniDf) + # detect change + expect_equal(uiOmega$iniDf$est, c(1, 3)) + expect_equal(newMod$iniDf$est, c(1, 0)) - # Confirm that you can simulate from the model - suppressMessages( - expect_equal( - rxSolve(newMod, events = data.frame(TIME = 0:2))$b, - rep(1, 3) + suppressMessages( + expect_warning( + newMod <- zeroRe(modSigmaBound, which = c("omega", "sigma")), + regexp = "No omega parameters in the model" + ) ) - ) - - # Confirm that the `fix` flag is respected - expect_silent( suppressMessages( - newUiNoFix <- zeroRe(uiOmegaSigma, which = c("omega", "sigma"), fix = FALSE) + expect_warning( + newUi <- zeroRe(uiSigmaBound, which = c("omega", "sigma")), + regexp = "No omega parameters in the model" + ) ) - ) - # detect change - expect_equal(uiOmegaSigma$iniDf$fix, rep(FALSE, 3)) - expect_equal(newUi$iniDf$fix, c(FALSE, TRUE, TRUE)) - expect_equal(newUiNoFix$iniDf$fix, rep(FALSE, 3)) + expect_equal(newMod$iniDf, newUi$iniDf) + # detect change + expect_equal(uiSigmaBound$iniDf$est, c(1, 2)) + expect_equal(newMod$iniDf$est, c(1, 0)) + # confirm lower bound change + expect_equal(uiSigmaBound$iniDf$lower, c(-Inf, 1)) + expect_equal(newMod$iniDf$lower, c(-Inf, 0)) - suppressMessages( - expect_warning( - newMod <- zeroRe(modOmega, which = c("omega", "sigma")), - regexp = "No sigma parameters in the model" + suppressMessages( + expect_warning( + newMod <- zeroRe(modSigma, which = c("omega", "sigma")), + regexp = "No omega parameters in the model" + ) ) - ) - suppressMessages( - expect_warning( - newUi <- zeroRe(uiOmega, which = c("omega", "sigma")), - regexp = "No sigma parameters in the model" + suppressMessages( + expect_warning( + newUi <- zeroRe(uiSigma, which = c("omega", "sigma")), + regexp = "No omega parameters in the model" + ) ) - ) - expect_equal(newMod$iniDf, newUi$iniDf) - # detect change - expect_equal(uiOmega$iniDf$est, c(1, 3)) - expect_equal(newMod$iniDf$est, c(1, 0)) + expect_equal(newMod$iniDf, newUi$iniDf) + # detect change + expect_equal(uiSigma$iniDf$est, c(1, 2)) + expect_equal(newMod$iniDf$est, c(1, 0)) - suppressMessages( - expect_warning( - newMod <- zeroRe(modSigmaBound, which = c("omega", "sigma")), - regexp = "No omega parameters in the model" - ) - ) - suppressMessages( - expect_warning( - newUi <- zeroRe(uiSigmaBound, which = c("omega", "sigma")), - regexp = "No omega parameters in the model" - ) - ) - expect_equal(newMod$iniDf, newUi$iniDf) - # detect change - expect_equal(uiSigmaBound$iniDf$est, c(1, 2)) - expect_equal(newMod$iniDf$est, c(1, 0)) - # confirm lower bound change - expect_equal(uiSigmaBound$iniDf$lower, c(-Inf, 1)) - expect_equal(newMod$iniDf$lower, c(-Inf, 0)) - - suppressMessages( - expect_warning( - newMod <- zeroRe(modSigma, which = c("omega", "sigma")), - regexp = "No omega parameters in the model" + suppressMessages( + expect_warning(expect_warning( + newMod <- zeroRe(modNone, which = c("omega", "sigma")), + regexp = "No omega parameters in the model"), + regexp = "No sigma parameters in the model" + ) ) - ) - suppressMessages( - expect_warning( - newUi <- zeroRe(uiSigma, which = c("omega", "sigma")), - regexp = "No omega parameters in the model" + suppressMessages( + expect_warning(expect_warning( + newUi <- zeroRe(uiNone, which = c("omega", "sigma")), + regexp = "No omega parameters in the model"), + regexp = "No sigma parameters in the model" + ) ) - ) - expect_equal(newMod$iniDf, newUi$iniDf) - # detect change - expect_equal(uiSigma$iniDf$est, c(1, 2)) - expect_equal(newMod$iniDf$est, c(1, 0)) - - suppressMessages( - expect_warning(expect_warning( - newMod <- zeroRe(modNone, which = c("omega", "sigma")), - regexp = "No omega parameters in the model"), - regexp = "No sigma parameters in the model" - ) - ) - suppressMessages( - expect_warning(expect_warning( - newUi <- zeroRe(uiNone, which = c("omega", "sigma")), - regexp = "No omega parameters in the model"), - regexp = "No sigma parameters in the model" - ) - ) - expect_equal(newMod$iniDf, newUi$iniDf) - # detect no change - expect_equal(uiNone$iniDf$est, 1) - expect_equal(newMod$iniDf$est, 1) - - # expected errors - expect_error(zeroRe("A"), regexp = "'object' needs to be a rxUi model") - expect_error(zeroRe(modOmegaSigma, which = "foo"), regexp = "should be one of") - }) - - test_that("zeroRe works with correlated etas (#480)", { - mod <- function() { - ini({ - lka <- 0.45 - lcl <- 1 - lvc <- 3.45 - propSd <- c(0, 0.5) - etalka + etalcl + etalvc ~ c(0.1, 0.2, 0.3, 0.4, 0.5, 0.6) - }) - model({ - ka <- exp(lka + etalka) - cl <- exp(lcl + etalcl) - vc <- exp(lvc + etalvc) - cp <- linCmt() - cp ~ prop(propSd) - }) - } - ui <- rxode2(mod) - expect_equal(ui$iniDf$est[!is.na(ui$iniDf$neta1)], (1:6)/10) - suppressMessages(zeroUi <- zeroRe(mod)) - expect_equal(zeroUi$iniDf$est[!is.na(zeroUi$iniDf$neta1)], c(0, 0, 0)) - }) - - test_that("Piping outside the boundaries", { - - m1 <- function() { - ini({ - x2 <- c(0, 1) - x3 <- c(0, 1, 2) - }) - model({ - f <- x2+x3*4 - }) - } - - suppressMessages({ - f2 <- m1 %>% ini(x2=-1) - expect_equal(f2$iniDf[f2$iniDf$name == "x2","lower"], -Inf) + expect_equal(newMod$iniDf, newUi$iniDf) + # detect no change + expect_equal(uiNone$iniDf$est, 1) + expect_equal(newMod$iniDf$est, 1) + + # expected errors + expect_error(zeroRe("A"), regexp = "'object' needs to be a rxUi model") + expect_error(zeroRe(modOmegaSigma, which = "foo"), regexp = "should be one of") }) - suppressMessages({ - f2 <- m1 %>% ini(x3=4) - expect_equal(f2$iniDf[f2$iniDf$name == "x3","upper"], Inf) - }) - suppressMessages({ - f2 <- m1 %>% ini(x3=c(0,3)) - expect_equal(f2$iniDf[f2$iniDf$name == "x3","upper"], Inf) + + test_that("zeroRe works with correlated etas (#480)", { + mod <- function() { + ini({ + lka <- 0.45 + lcl <- 1 + lvc <- 3.45 + propSd <- c(0, 0.5) + etalka + etalcl + etalvc ~ c(0.1, 0.2, 0.3, 0.4, 0.5, 0.6) + }) + model({ + ka <- exp(lka + etalka) + cl <- exp(lcl + etalcl) + vc <- exp(lvc + etalvc) + cp <- linCmt() + cp ~ prop(propSd) + }) + } + ui <- rxode2(mod) + expect_equal(ui$iniDf$est[!is.na(ui$iniDf$neta1)], (1:6)/10) + suppressMessages(zeroUi <- zeroRe(mod)) + expect_equal(zeroUi$iniDf$est[!is.na(zeroUi$iniDf$neta1)], c(0, 0, 0)) }) - }) - test_that("append allows promoting from covariate (#472)", { - mod <- function() { - ini({ - lka <- 0.45 - lcl <- 1 - lvc <- 3.45 - propSd <- 0.5 + test_that("Piping outside the boundaries", { + + m1 <- function() { + ini({ + x2 <- c(0, 1) + x3 <- c(0, 1, 2) + }) + model({ + f <- x2+x3*4 + }) + } + + suppressMessages({ + f2 <- m1 %>% ini(x2=-1) + expect_equal(f2$iniDf[f2$iniDf$name == "x2","lower"], -Inf) }) - model({ - ka <- exp(lka) - cl <- exp(lcl) - vc <- exp(lvc) - - kel <- cl / vc - - d/dt(depot) <- -ka*depot - d/dt(central) <- ka*depot-kel*central - - cp <- central / vc - cp ~ prop(propSd) + suppressMessages({ + f2 <- m1 %>% ini(x3=4) + expect_equal(f2$iniDf[f2$iniDf$name == "x3","upper"], Inf) }) - } - suppressMessages( - newmod <- - mod %>% - model( - ka <- exp(lka + ka_dose*DOSE), - auto = FALSE - ) %>% - ini( - ka_dose <- 1, - append = "lka" - ) - ) - expect_equal(newmod$iniDf$name, c("lka", "ka_dose", "lcl", "lvc", "propSd")) - }) - - test_that("change ini type with ~", { - - mod <- function() { - ini({ - lka <- 0.45 - lcl <- 1 - lvc <- 3.45 - propSd <- 0.5 + suppressMessages({ + f2 <- m1 %>% ini(x3=c(0,3)) + expect_equal(f2$iniDf[f2$iniDf$name == "x3","upper"], Inf) }) - model({ - ka <- exp(lka) - cl <- exp(lcl) - vc <- exp(lvc) - kel <- cl / vc - d/dt(depot) <- -ka*depot - d/dt(central) <- ka*depot-kel*central - cp <- central / vc - cp ~ prop(propSd) - }) - } - - mod1 <- mod |> ini( ~ lka) - expect_equal(mod1$omega, lotri(lka ~ 0.45)) + }) - mod2 <- mod1 |> ini( ~ lka) - expect_equal(mod2$omega, NULL) + test_that("append allows promoting from covariate (#472)", { + mod <- function() { + ini({ + lka <- 0.45 + lcl <- 1 + lvc <- 3.45 + propSd <- 0.5 + }) + model({ + ka <- exp(lka) + cl <- exp(lcl) + vc <- exp(lvc) + + kel <- cl / vc + + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot-kel*central + + cp <- central / vc + cp ~ prop(propSd) + }) + } + suppressMessages( + newmod <- + mod %>% + model( + ka <- exp(lka + ka_dose*DOSE), + auto = FALSE + ) %>% + ini( + ka_dose <- 1, + append = "lka" + ) + ) + expect_equal(newmod$iniDf$name, c("lka", "ka_dose", "lcl", "lvc", "propSd")) + }) - expect_error(mod1 |> ini( ~ propSd)) + test_that("change ini type with ~", { + + mod <- function() { + ini({ + lka <- 0.45 + lcl <- 1 + lvc <- 3.45 + propSd <- 0.5 + }) + model({ + ka <- exp(lka) + cl <- exp(lcl) + vc <- exp(lvc) + kel <- cl / vc + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot-kel*central + cp <- central / vc + cp ~ prop(propSd) + }) + } + + mod1 <- mod |> ini( ~ lka) + expect_equal(mod1$omega, lotri(lka ~ 0.45)) + + mod2 <- mod1 |> ini( ~ lka) + expect_equal(mod2$omega, NULL) + + expect_error(mod1 |> ini( ~ propSd)) + + expect_error(mod1 |> ini( ~ matt)) + + ## all etas + + mod <- function() { + ini({ + lka ~ 0.45 + lcl ~ 1 + lvc ~ 3.45 + }) + model({ + ka <- exp(lka) + cl <- exp(lcl) + vc <- exp(lvc) + kel <- cl / vc + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot-kel*central + cp <- central / vc + }) + } + + mod2 <- mod |> ini( ~ lka) + + expect_equal(mod2$omega, lotri(lcl ~ 1, lvc ~ 3.45)) + + # remove correlated eta + + mod <- function() { + ini({ + lka + lcl + lvc ~ + c(0.45, + 0.01, 1, + 0.01, -0.01, 3.45) + }) + model({ + ka <- exp(lka) + cl <- exp(lcl) + vc <- exp(lvc) + kel <- cl / vc + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot-kel*central + cp <- central / vc + }) + } + + mod2 <- mod |> ini( ~ lka) + + expect_equal(mod2$omega, lotri(lcl + lvc ~ c(1, + -0.01, 3.45))) + + + # negative and zero + + mod <- function() { + ini({ + lka <- 0.45 + lcl <- -1 + lvc <- 0 + }) + model({ + ka <- exp(lka) + cl <- exp(lcl) + vc <- exp(lvc) + kel <- cl / vc + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot-kel*central + cp <- central / vc + }) + } + + mod2 <- mod |> ini( ~ lcl) + + expect_equal(mod2$omega, lotri(lcl ~ 1)) + + mod2 <- mod |> ini( ~ lvc) + + expect_equal(mod2$omega, lotri(lvc ~ 1)) + + mod3 <- mod2 |> ini( ~ lvc) + + expect_equal(mod3$omega, NULL) + + mod4 <- mod3 |> ini( ~ lvc) + + expect_equal(mod4$omega, lotri(lvc ~ 1)) - expect_error(mod1 |> ini( ~ matt)) + }) - ## all etas - mod <- function() { - ini({ - lka ~ 0.45 - lcl ~ 1 - lvc ~ 3.45 - }) - model({ - ka <- exp(lka) - cl <- exp(lcl) - vc <- exp(lvc) - kel <- cl / vc - d/dt(depot) <- -ka*depot - d/dt(central) <- ka*depot-kel*central - cp <- central / vc - }) - } - mod2 <- mod |> ini( ~ lka) + test_that("change ini variable to covariate with -", { + + mod <- function() { + ini({ + lka + lcl + lvc ~ + c(0.45, + 0.01, 1, + 0.01, -0.01, 3.45) + }) + model({ + ka <- exp(lka) + cl <- exp(lcl) + vc <- exp(lvc) + kel <- cl / vc + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot-kel*central + cp <- central / vc + }) + } + + mod2 <- mod |> ini(-lka) + + expect_equal(mod2$allCovs, "lka") + expect_equal(mod2$omega, lotri(lcl + lvc ~ c(1, -0.01, 3.45))) + + mod <- function() { + ini({ + lka ~ 0.45 + lcl ~ 1 + lvc ~ 3.45 + }) + model({ + ka <- exp(lka) + cl <- exp(lcl) + vc <- exp(lvc) + kel <- cl / vc + d/dt(depot) <- -ka*depot + d/dt(central) <- ka*depot-kel*central + cp <- central / vc + }) + } + + mod2 <- mod |> ini(-lka) + + expect_equal(mod2$allCovs, "lka") - expect_equal(mod2$omega, lotri(lcl ~ 1, lvc ~ 3.45)) - # remove correlated eta + }) + } - mod <- function() { + test_that("empty arguments to rxRename() give a warning (#688)", { + mod1 <- function() { ini({ - lka + lcl + lvc ~ - c(0.45, - 0.01, 1, - 0.01, -0.01, 3.45) + Kin=1 }) model({ - ka <- exp(lka) - cl <- exp(lcl) - vc <- exp(lvc) - kel <- cl / vc - d/dt(depot) <- -ka*depot - d/dt(central) <- ka*depot-kel*central - cp <- central / vc + eff <- Kin }) } - mod2 <- mod |> ini( ~ lka) - - expect_equal(mod2$omega, lotri(lcl + lvc ~ c(1, - -0.01, 3.45))) - - - # negative and zero + expect_warning( + rxRename(mod1, ), + "empty argument ignored" + ) + expect_warning( + rxRename(mod1, foo = eff, ), + "empty argument ignored" + ) + }) - mod <- function() { - ini({ - lka <- 0.45 - lcl <- -1 - lvc <- 0 - }) + test_that("parameters can be promoted from covariate to parameter with bounds (#692)", { + mod1 <- function() { model({ - ka <- exp(lka) - cl <- exp(lcl) - vc <- exp(lvc) - kel <- cl / vc - d/dt(depot) <- -ka*depot - d/dt(central) <- ka*depot-kel*central - cp <- central / vc + eff <- Kin }) } - mod2 <- mod |> ini( ~ lcl) - - expect_equal(mod2$omega, lotri(lcl ~ 1)) - - mod2 <- mod |> ini( ~ lvc) - - expect_equal(mod2$omega, lotri(lvc ~ 1)) - - mod3 <- mod2 |> ini( ~ lvc) - - expect_equal(mod3$omega, NULL) - - mod4 <- mod3 |> ini( ~ lvc) - - expect_equal(mod4$omega, lotri(lvc ~ 1)) - + expect_message( + mod1 %>% ini(Kin = 2), + "promote `Kin` to population parameter with initial estimate 2" + ) + expect_message( + expect_message( + mod1 %>% ini(Kin = c(1, 2)), + "promote `Kin` to population parameter with initial estimate 2" + ), + regexp = "change initial estimate (2) and lower bound (1) of `Kin`", + fixed = TRUE + ) + expect_message( + expect_message( + mod1 %>% ini(Kin = c(1, 2, 3)), + "promote `Kin` to population parameter with initial estimate 2" + ), + regexp = "change initial estimate (2) and upper/lower bound (1 to 3) of `Kin`", + fixed = TRUE + ) }) + test_that("ini(diag) and ini(-cov()) tests", { - - test_that("change ini variable to covariate with -", { - - mod <- function() { + mod2 <- function() { ini({ - lka + lcl + lvc ~ - c(0.45, - 0.01, 1, - 0.01, -0.01, 3.45) + lka ~ 0.45 + lcl ~ c(0.01, 1) + lvc ~ c(-0.01, 0.01, 3.45) + lfun ~ c(-0.1, 0.1, 0.01, 4) }) model({ ka <- exp(lka) @@ -793,20 +926,94 @@ if (!.Call(`_rxode2_isIntel`)) { kel <- cl / vc d/dt(depot) <- -ka*depot d/dt(central) <- ka*depot-kel*central - cp <- central / vc + cp <- central / vc + lfun }) } - mod2 <- mod |> ini(-lka) + expect_error( + mod2 %>% ini(diag(lcl, matt)), + "matt" + ) + + expect_error( + mod2 %>% ini(diag(matt, lcl)), + "matt" + ) - expect_equal(mod2$allCovs, "lka") - expect_equal(mod2$omega, lotri(lcl + lvc ~ c(1, -0.01, 3.45))) + tmp <- mod2 %>% ini(-cov(lcl, lvc)) + expect_equal(tmp$omega, + lotri({ + lvc ~ 3.45 + lfun ~ c(0.01, 4) + lka ~ c(-0.01, -0.1, 0.45) + lcl ~ c(0, 0.1, 0.01, 1) + })) + + tmp <- mod2 %>% ini(-cor(lcl, lvc)) + expect_equal(tmp$omega, + lotri({ + lvc ~ 3.45 + lfun ~ c(0.01, 4) + lka ~ c(-0.01, -0.1, 0.45) + lcl ~ c(0, 0.1, 0.01, 1) + })) + + tmp <- mod2 %>% ini(cor(lcl, lvc) <- NULL) + + expect_equal(tmp$omega, + lotri({ + lvc ~ 3.45 + lfun ~ c(0.01, 4) + lka ~ c(-0.01, -0.1, 0.45) + lcl ~ c(0, 0.1, 0.01, 1) + })) + + tmp <- mod2 %>% ini(cor(lcl, lvc) ~ NULL) + expect_equal(tmp$omega, + lotri({ + lvc ~ 3.45 + lfun ~ c(0.01, 4) + lka ~ c(-0.01, -0.1, 0.45) + lcl ~ c(0, 0.1, 0.01, 1) + })) + + expect_error(mod2 %>% ini(diag(matt)), + "matt") + + # Will reorder + tmp <- mod2 %>% ini(diag(lcl, lvc)) + expect_equal(tmp$omega, + lotri({ + lfun ~ 4 + lka ~ c(-0.1, 0.45) + lvc ~ 3.45 + lcl ~ 1 + })) + + tmp <- mod2 %>% ini(diag) + expect_equal(tmp$omega, + lotri({ + lka ~ 0.45 + lcl ~ 1 + lvc ~ 3.45 + lfun ~ 4 + })) + + tmp <- mod2 %>% ini(diag(lvc)) + + expect_equal(tmp$omega, + lotri({ + lfun ~ 4 + lcl ~ c(0.1, 1) + lka ~ c(-0.1, 0.01, 0.45) + lvc ~ 3.45 + })) mod <- function() { ini({ lka ~ 0.45 - lcl ~ 1 - lvc ~ 3.45 + lcl ~ c(0.01, 1) + lvc ~ c(-0.01, 0.01, 3.45) }) model({ ka <- exp(lka) @@ -819,59 +1026,24 @@ if (!.Call(`_rxode2_isIntel`)) { }) } - mod2 <- mod |> ini(-lka) - - expect_equal(mod2$allCovs, "lka") + tmp <- mod %>% ini(diag) - }) -} + expect_equal(tmp$omega, + lotri({ + lka ~ 0.45 + lcl ~ 1 + lvc ~ 3.45 + })) -test_that("empty arguments to rxRename() give a warning (#688)", { - mod1 <- function() { - ini({ - Kin=1 - }) - model({ - eff <- Kin - }) - } + tmp <- mod %>% ini(diag()) - expect_warning( - rxRename(mod1, ), - "empty argument ignored" - ) - expect_warning( - rxRename(mod1, foo = eff, ), - "empty argument ignored" - ) -}) + expect_equal(tmp$omega, + lotri({ + lka ~ 0.45 + lcl ~ 1 + lvc ~ 3.45 + })) -test_that("parameters can be promoted from covariate to parameter with bounds (#692)", { - mod1 <- function() { - model({ - eff <- Kin - }) - } - - expect_message( - mod1 %>% ini(Kin = 2), - "promote `Kin` to population parameter with initial estimate 2" - ) - expect_message( - expect_message( - mod1 %>% ini(Kin = c(1, 2)), - "promote `Kin` to population parameter with initial estimate 2" - ), - regexp = "change initial estimate (2) and lower bound (1) of `Kin`", - fixed = TRUE - ) - expect_message( - expect_message( - mod1 %>% ini(Kin = c(1, 2, 3)), - "promote `Kin` to population parameter with initial estimate 2" - ), - regexp = "change initial estimate (2) and upper/lower bound (1 to 3) of `Kin`", - fixed = TRUE - ) + }) }) diff --git a/tests/testthat/test-rhs.R b/tests/testthat/test-rhs.R index c47ca7060..7b8cc55f3 100644 --- a/tests/testthat/test-rhs.R +++ b/tests/testthat/test-rhs.R @@ -1,9 +1,10 @@ -if (!.Call(`_rxode2_isIntel`)) { - # rxSolve right handed differental equations +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + # rxSolve right handed differental equations - rxSetIni0(FALSE) + rxSetIni0(FALSE) - orhs <- rxode2(" + orhs <- rxode2(" x(0) = 1 a = 1.0E4 d/dt(x) = a*y*z - 0.04*x @@ -12,54 +13,39 @@ d/dt(y) = -1.0*(d/dt(x)+d/dt(z)) ") - et <- eventTable() - et$add.sampling(c(4 * 10^seq(-1, 10))) + et <- eventTable() + et$add.sampling(c(4 * 10^seq(-1, 10))) - ## print(o1); - test_that("rxSolve produces the correct results for rhs", { - expect_warning(o1 <- rxSolve(orhs, et)) + ## print(o1); + test_that("rxSolve produces the correct results for rhs", { + expect_warning(o1 <- rxSolve(orhs, et)) - ## expect_warning(rxSolve(orhs,et),"The initial conditions are at t = 0.4 instead of t = 0.") - expect_equal(round(as.data.frame(o1), 4), - structure(list(time = c( - 0.4, 4, 40, 400, 4000, 40000, 4e+05, - 4e+06, 4e+07, 4e+08, 4e+09, 4e+10 - ), x = c( - 1, 0.9117, 0.7168, - 0.4506, 0.1832, 0.039, 0.0049, -832.9988, -18106.8843, -190902.2423, - -1918897.229, -19198891.1895 - ), z = c( - 0, 0.0882, 0.2831, 0.5494, - 0.8168, 0.961, 0.9951, 833.9988, 18107.8843, 190903.2423, 1918898.229, - 19198892.1895 - ), y = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)), row.names = c( - NA, - -12L - ), class = "data.frame"), - tolerance = 1e-4 - ) + ## expect_warning(rxSolve(orhs,et),"The initial conditions are at t = 0.4 instead of t = 0.") + df <- data.frame(time = c(0.4, 4, 40, 400, 4000, 40000, 4e+05, 4e+06, 4e+07, + 4e+08, 4e+09, 4e+10), + x = c(1, 0.9117, 0.7168, 0.4506, 0.1832, 0.039, 0.0049, 5e-04, + 1e-04, 0, 0, 0), + z = c(0, 0.0882, 0.2831, 0.5494, 0.8168, 0.961, 0.9951, 0.9995, + 0.9999, 1, 1, 1), + y = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) - o1$add.sampling(0) + expect_equal(round(as.data.frame(o1), 4), df, tolerance = 1e-4) - expect_equal(round(as.data.frame(o1), 4), - structure(list(time = c( - 0, 0.4, 4, 40, 400, 4000, 40000, 4e+05, - 4e+06, 4e+07, 4e+08, 4e+09, 4e+10 - ), x = c( - 1, 0.9852, 0.9055, - 0.7158, 0.4505, 0.1832, 0.039, 0.0049, -832.9941, -18106.8732, - -190902.279, -1918898.6518, -19198893.9661 - ), z = c( - 0, 0.0148, - 0.0945, 0.2842, 0.5495, 0.8168, 0.961, 0.9951, 833.9941, 18107.8732, - 190903.279, 1918899.6518, 19198894.9661 - ), y = c( - 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0 - )), row.names = c(NA, 13L), class = "data.frame"), - tolerance = 1e-4 - ) - }) + o1$add.sampling(0) - rxSetIni0(TRUE) -} + df2 <- data.frame(time = c(0, 0.4, 4, 40, 400, 4000, 40000, 4e+05, + 4e+06, 4e+07, 4e+08, 4e+09, 4e+10), + x = c(1, 0.9852, 0.9055, 0.7158, 0.4505, 0.1832, + 0.039, 0.0049, 5e-04, 1e-04, 0, 0, 0), + z = c(0, 0.0148, 0.0945, 0.2842, 0.5495, 0.8168, 0.961, + 0.9951, 0.9995, 0.9999, 1, 1, 1), + y = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) + + expect_equal(round(as.data.frame(o1), 4), df2, + tolerance = 1e-4) + + }) + + rxSetIni0(TRUE) + } +}) diff --git a/tests/testthat/test-rlkj.R b/tests/testthat/test-rlkj.R index 1031206e4..2885eecb8 100644 --- a/tests/testthat/test-rlkj.R +++ b/tests/testthat/test-rlkj.R @@ -1,339 +1,341 @@ -if (!.Call(`_rxode2_isIntel`)) { - ## Adapted from https://github.com/biobakery/banocc/blob/master/tests/testthat/test_utils_rlkj.R - # context("Utilities - rLKJ1") - d_vals <- c(2, 5) # seq(2, 200, 10) - eta_vals <- c(1, 50) # seq(1, 200, 10) +rxTest({ + if (!.Call(`_rxode2_isIntel`)) { + ## Adapted from https://github.com/biobakery/banocc/blob/master/tests/testthat/test_utils_rlkj.R + # context("Utilities - rLKJ1") + d_vals <- c(2, 5) # seq(2, 200, 10) + eta_vals <- c(1, 50) # seq(1, 200, 10) - test_that("rLKJ1 returns a matrix", { - for (d in d_vals) { - for (eta in eta_vals) { - eval(bquote(expect_true(is.matrix(rLKJ1(d = .(d), eta = .(eta)))))) + test_that("rLKJ1 returns a matrix", { + for (d in d_vals) { + for (eta in eta_vals) { + eval(bquote(expect_true(is.matrix(rLKJ1(d = .(d), eta = .(eta)))))) + eval(bquote( + expect_true(is.matrix(rLKJ1(d = .(d), eta = .(eta), cholesky = TRUE))) + )) + } + } + }) + + test_that("rLKJ1 returns square matrix", { + test_square <- function(d, e, ch) { + r <- rLKJ1(d = d, eta = e, cholesky = ch) + expect_equal(nrow(r), ncol(r)) + } + for (d in d_vals) { + for (eta in eta_vals) { + test_square(d, eta, FALSE) + test_square(d, eta, TRUE) + } + } + }) + + test_that("rLKJ1 returns matrix with d rows", { + test_nrow <- function(d, e, ch) { eval(bquote( - expect_true(is.matrix(rLKJ1(d = .(d), eta = .(eta), cholesky = TRUE))) + expect_equal(nrow(rLKJ1(d = .(d), eta = .(e), cholesky = .(ch))), .(d)) )) } - } - }) + for (d in d_vals) { + for (eta in eta_vals) { + test_nrow(d, eta, TRUE) + test_nrow(d, eta, FALSE) + } + } + }) + + test_that("rLKJ1 returns positive definite matrix if cholesky=FALSE", { + test_pd <- function(d, e) { + eval(bquote(expect_true(all(eigen(rLKJ1(d = .(d), eta = .(e)))$values > 0)))) + } + for (d in d_vals) { + for (eta in eta_vals) { + test_pd(d, eta) + } + } + }) - test_that("rLKJ1 returns square matrix", { - test_square <- function(d, e, ch) { - r <- rLKJ1(d = d, eta = e, cholesky = ch) - expect_equal(nrow(r), ncol(r)) - } - for (d in d_vals) { - for (eta in eta_vals) { - test_square(d, eta, FALSE) - test_square(d, eta, TRUE) - } - } - }) + test_that("rLKJ1 returns symmetric matrix if cholesky=FALSE", { + get_tri <- function(mat, type) { + if (type == "lower") { + t(mat)[upper.tri(mat)] + } else { + mat[upper.tri(mat)] + } + } + test_symmetric <- function(d, e) { + l <- rLKJ1(d = d, eta = e) + expect_equal( + get_tri(l, "lower"), + get_tri(l, "upper") + ) + } + for (d in d_vals) { + for (eta in eta_vals) { + test_symmetric(d, eta) + } + } + }) - test_that("rLKJ1 returns matrix with d rows", { - test_nrow <- function(d, e, ch) { - eval(bquote( - expect_equal(nrow(rLKJ1(d = .(d), eta = .(e), cholesky = .(ch))), .(d)) - )) - } - for (d in d_vals) { - for (eta in eta_vals) { - test_nrow(d, eta, TRUE) - test_nrow(d, eta, FALSE) - } - } - }) + test_that("rLKJ1 returns matrix with diagonal elts 1 if cholesky=FALSE", { + test_diag <- function(d, e) { + eval(bquote( + expect_equal(diag(rLKJ1(d = .(d), eta = .(e))), rep(1, .(d))) + )) + } + for (d in d_vals) { + for (eta in eta_vals) { + test_diag(d, eta) + } + } + }) - test_that("rLKJ1 returns positive definite matrix if cholesky=FALSE", { - test_pd <- function(d, e) { - eval(bquote(expect_true(all(eigen(rLKJ1(d = .(d), eta = .(e)))$values > 0)))) - } - for (d in d_vals) { - for (eta in eta_vals) { - test_pd(d, eta) - } - } - }) + test_that("rLKJ1 returns matrix with elts between -1 and 1 if cholesky=FALSE", { + test_elts <- function(d, e) { + r <- rLKJ1(d = d, eta = e) + r[upper.tri(r)] + } + for (d in d_vals) { + for (eta in eta_vals) { + expect_true(all(test_elts(d, eta) >= -1)) + expect_true(all(test_elts(d, eta) <= 1)) + } + } + }) - test_that("rLKJ1 returns symmetric matrix if cholesky=FALSE", { - get_tri <- function(mat, type) { - if (type == "lower") { - t(mat)[upper.tri(mat)] - } else { + test_that("rLKJ1 returns matrix with upper triangle of 0 if cholesky=TRUE", { + get_uppertri <- function(mat) { mat[upper.tri(mat)] } - } - test_symmetric <- function(d, e) { - l <- rLKJ1(d = d, eta = e) - expect_equal( - get_tri(l, "lower"), - get_tri(l, "upper") - ) - } - for (d in d_vals) { - for (eta in eta_vals) { - test_symmetric(d, eta) - } - } - }) - - test_that("rLKJ1 returns matrix with diagonal elts 1 if cholesky=FALSE", { - test_diag <- function(d, e) { - eval(bquote( - expect_equal(diag(rLKJ1(d = .(d), eta = .(e))), rep(1, .(d))) - )) - } - for (d in d_vals) { - for (eta in eta_vals) { - test_diag(d, eta) - } - } - }) + test_uppertri <- function(d, e) { + eval(bquote( + expect_equal( + get_uppertri(rLKJ1(d = .(d), eta = .(e), cholesky = TRUE)), + rep(0, choose(.(d), 2)) + ) + )) + } + for (d in d_vals) { + for (eta in eta_vals) { + test_uppertri(d, eta) + } + } + }) - test_that("rLKJ1 returns matrix with elts between -1 and 1 if cholesky=FALSE", { - test_elts <- function(d, e) { - r <- rLKJ1(d = d, eta = e) - r[upper.tri(r)] - } - for (d in d_vals) { - for (eta in eta_vals) { - expect_true(all(test_elts(d, eta) >= -1)) - expect_true(all(test_elts(d, eta) <= 1)) - } - } - }) + test_that("rLKJ1 corr matrix is positive definite if cholesky=TRUE", { + test_pd <- function(d, e) { + l <- rLKJ1(d = d, eta = e, cholesky = TRUE) + eigen(l %*% t(l))$values + } + for (d in d_vals) { + for (eta in eta_vals) { + expect_true(all(test_pd(d, eta) > 0)) + } + } + }) - test_that("rLKJ1 returns matrix with upper triangle of 0 if cholesky=TRUE", { - get_uppertri <- function(mat) { - mat[upper.tri(mat)] - } - test_uppertri <- function(d, e) { - eval(bquote( - expect_equal( - get_uppertri(rLKJ1(d = .(d), eta = .(e), cholesky = TRUE)), - rep(0, choose(.(d), 2)) - ) - )) - } - for (d in d_vals) { - for (eta in eta_vals) { - test_uppertri(d, eta) - } - } - }) + test_that("rLKJ1 corr matrix is symmetric if cholesky=TRUE", { + get_tri <- function(mat, type) { + if (type == "lower") { + t(mat)[upper.tri(mat)] + } else { + mat[upper.tri(mat)] + } + } + test_symmetric <- function(d, e) { + l <- rLKJ1(d = d, eta = e, cholesky = TRUE) + r <- l %*% t(l) + expect_equal(get_tri(r, "lower"), get_tri(r, "upper")) + } + for (d in d_vals) { + for (eta in eta_vals) { + test_symmetric(d, eta) + } + } + }) - test_that("rLKJ1 corr matrix is positive definite if cholesky=TRUE", { - test_pd <- function(d, e) { - l <- rLKJ1(d = d, eta = e, cholesky = TRUE) - eigen(l %*% t(l))$values - } - for (d in d_vals) { - for (eta in eta_vals) { - expect_true(all(test_pd(d, eta) > 0)) - } - } - }) + test_that("rLKJ1 corr matrix has diagonal elements of 1 if cholesky=TRUE", { + test_diag <- function(d, e) { + l <- rLKJ1(d = d, eta = e, cholesky = TRUE) + diag(l %*% t(l)) + } + for (d in d_vals) { + for (eta in eta_vals) { + expect_equal(test_diag(d, eta), rep(1, d)) + } + } + }) - test_that("rLKJ1 corr matrix is symmetric if cholesky=TRUE", { - get_tri <- function(mat, type) { - if (type == "lower") { - t(mat)[upper.tri(mat)] - } else { - mat[upper.tri(mat)] + test_that("rLKJ1 corr matrix has elts between -1 and 1 if cholesky=TRUE", { + test_elts <- function(d, e) { + l <- rLKJ1(d = d, eta = e, cholesky = TRUE) + (l %*% t(l))[upper.tri(l)] + } + for (d in d_vals) { + for (eta in eta_vals) { + expect_true(all(test_elts(d, eta) >= -1)) + expect_true(all(test_elts(d, eta) <= 1)) + } } - } - test_symmetric <- function(d, e) { - l <- rLKJ1(d = d, eta = e, cholesky = TRUE) - r <- l %*% t(l) - expect_equal(get_tri(r, "lower"), get_tri(r, "upper")) - } - for (d in d_vals) { - for (eta in eta_vals) { - test_symmetric(d, eta) - } - } - }) + }) - test_that("rLKJ1 corr matrix has diagonal elements of 1 if cholesky=TRUE", { - test_diag <- function(d, e) { - l <- rLKJ1(d = d, eta = e, cholesky = TRUE) - diag(l %*% t(l)) - } - for (d in d_vals) { - for (eta in eta_vals) { - expect_equal(test_diag(d, eta), rep(1, d)) - } - } - }) + test_that("rLKJ1 gives error if eta < 1", { + err_string <- "must be >= 1" + for (d in d_vals) { + for (eta in c(-1, 0)) { + expect_error(rLKJ1(d = d, eta = eta, cholesky = TRUE), err_string) + expect_error(rLKJ1(d = d, eta = eta, cholesky = FALSE), err_string) + } + } + }) - test_that("rLKJ1 corr matrix has elts between -1 and 1 if cholesky=TRUE", { - test_elts <- function(d, e) { - l <- rLKJ1(d = d, eta = e, cholesky = TRUE) - (l %*% t(l))[upper.tri(l)] - } - for (d in d_vals) { - for (eta in eta_vals) { - expect_true(all(test_elts(d, eta) >= -1)) - expect_true(all(test_elts(d, eta) <= 1)) - } - } - }) + test_that("rLKJ1 gives error if d < 2", { + err_string <- "must be > 1" + for (d in c(-1, 0, 1)) { + for (eta in eta_vals) { + expect_error(rLKJ1(d = d, eta = eta, cholesky = TRUE), err_string) + expect_error(rLKJ1(d = d, eta = eta, cholesky = FALSE), err_string) + } + } + }) - test_that("rLKJ1 gives error if eta < 1", { - err_string <- "must be >= 1" - for (d in d_vals) { - for (eta in c(-1, 0)) { - expect_error(rLKJ1(d = d, eta = eta, cholesky = TRUE), err_string) - expect_error(rLKJ1(d = d, eta = eta, cholesky = FALSE), err_string) - } - } - }) + # context("Utilities - invWR1d") + nu_vals <- c(4.5, 50) + d_vals <- c(2, 5) - test_that("rLKJ1 gives error if d < 2", { - err_string <- "must be > 1" - for (d in c(-1, 0, 1)) { - for (eta in eta_vals) { - expect_error(rLKJ1(d = d, eta = eta, cholesky = TRUE), err_string) - expect_error(rLKJ1(d = d, eta = eta, cholesky = FALSE), err_string) - } - } - }) + test_that("invWR1d returns a matrix", { + for (d in d_vals) { + for (nu in nu_vals) { + expect_true(is.matrix(eval(bquote(invWR1d(d = .(d), nu = .(nu)))))) + eval(bquote( + expect_true(is.matrix(invWR1d(d = .(d), nu = .(nu)))) + )) + } + } + }) - # context("Utilities - invWR1d") - nu_vals <- c(4.5, 50) - d_vals <- c(2, 5) + test_that("invWR1d returns square matrix", { + test_square <- function(d, e) { + r <- invWR1d(d = d, nu = e) + expect_equal(nrow(r), ncol(r)) + } + for (d in d_vals) { + for (nu in nu_vals) { + test_square(d, nu) + } + } + }) - test_that("invWR1d returns a matrix", { - for (d in d_vals) { - for (nu in nu_vals) { - expect_true(is.matrix(eval(bquote(invWR1d(d = .(d), nu = .(nu)))))) + test_that("invWR1d returns matrix with d rows", { + test_nrow <- function(d, e) { eval(bquote( - expect_true(is.matrix(invWR1d(d = .(d), nu = .(nu)))) + expect_equal(nrow(invWR1d(d = .(d), nu = .(e))), .(d)) )) } - } - }) - - test_that("invWR1d returns square matrix", { - test_square <- function(d, e) { - r <- invWR1d(d = d, nu = e) - expect_equal(nrow(r), ncol(r)) - } - for (d in d_vals) { - for (nu in nu_vals) { - test_square(d, nu) - } - } - }) - - test_that("invWR1d returns matrix with d rows", { - test_nrow <- function(d, e) { - eval(bquote( - expect_equal(nrow(invWR1d(d = .(d), nu = .(e))), .(d)) - )) - } - for (d in d_vals) { - for (nu in nu_vals) { - test_nrow(d, nu) - } - } - }) + for (d in d_vals) { + for (nu in nu_vals) { + test_nrow(d, nu) + } + } + }) - test_that("invWR1d returns positive definite matrix if cholesky=FALSE", { - test_pd <- function(d, e) { - eval(bquote(expect_true(all(eigen(invWR1d(d = .(d), nu = .(e)))$values > 0)))) - } - for (d in d_vals) { - for (nu in nu_vals) { - test_pd(d, nu) - } - } - }) + test_that("invWR1d returns positive definite matrix if cholesky=FALSE", { + test_pd <- function(d, e) { + eval(bquote(expect_true(all(eigen(invWR1d(d = .(d), nu = .(e)))$values > 0)))) + } + for (d in d_vals) { + for (nu in nu_vals) { + test_pd(d, nu) + } + } + }) - test_that("invWR1d returns symmetric matrix", { - get_tri <- function(mat, type) { - if (type == "lower") { - t(mat)[upper.tri(mat)] - } else { - mat[upper.tri(mat)] + test_that("invWR1d returns symmetric matrix", { + get_tri <- function(mat, type) { + if (type == "lower") { + t(mat)[upper.tri(mat)] + } else { + mat[upper.tri(mat)] + } } - } - test_symmetric <- function(d, e) { - l <- invWR1d(d = d, nu = e) - expect_equal( - get_tri(l, "lower"), - get_tri(l, "upper") - ) - } - for (d in d_vals) { - for (nu in nu_vals) { - test_symmetric(d, nu) - } - } - }) + test_symmetric <- function(d, e) { + l <- invWR1d(d = d, nu = e) + expect_equal( + get_tri(l, "lower"), + get_tri(l, "upper") + ) + } + for (d in d_vals) { + for (nu in nu_vals) { + test_symmetric(d, nu) + } + } + }) - test_that("invWR1d returns matrix with diagonal elts 1", { - test_diag <- function(d, e) { - eval(bquote( - expect_equal(diag(invWR1d(d = .(d), nu = .(e))), rep(1, .(d))) - )) - } - for (d in d_vals) { - for (nu in nu_vals) { - test_diag(d, nu) - } - } - }) + test_that("invWR1d returns matrix with diagonal elts 1", { + test_diag <- function(d, e) { + eval(bquote( + expect_equal(diag(invWR1d(d = .(d), nu = .(e))), rep(1, .(d))) + )) + } + for (d in d_vals) { + for (nu in nu_vals) { + test_diag(d, nu) + } + } + }) - test_that("invWR1d returns matrix with elts between -1 and 1", { - test_elts <- function(d, e) { - r <- invWR1d(d = d, nu = e) - r[upper.tri(r)] - } - for (d in d_vals) { - for (nu in nu_vals) { - expect_true(all(test_elts(d, nu) >= -1)) - expect_true(all(test_elts(d, nu) <= 1)) - } - } - }) + test_that("invWR1d returns matrix with elts between -1 and 1", { + test_elts <- function(d, e) { + r <- invWR1d(d = d, nu = e) + r[upper.tri(r)] + } + for (d in d_vals) { + for (nu in nu_vals) { + expect_true(all(test_elts(d, nu) >= -1)) + expect_true(all(test_elts(d, nu) <= 1)) + } + } + }) - test_that("invWR1d corr matrix is positive definite", { - test_pd <- function(d, e) { - l <- invWR1d(d = d, nu = e) - eigen(l %*% t(l))$values - } - for (d in d_vals) { - for (nu in nu_vals) { - expect_true(all(test_pd(d, nu) > 0)) - } - } - }) + test_that("invWR1d corr matrix is positive definite", { + test_pd <- function(d, e) { + l <- invWR1d(d = d, nu = e) + eigen(l %*% t(l))$values + } + for (d in d_vals) { + for (nu in nu_vals) { + expect_true(all(test_pd(d, nu) > 0)) + } + } + }) - test_that("invWR1d corr matrix is symmetric", { - get_tri <- function(mat, type) { - if (type == "lower") { - t(mat)[upper.tri(mat)] - } else { - mat[upper.tri(mat)] + test_that("invWR1d corr matrix is symmetric", { + get_tri <- function(mat, type) { + if (type == "lower") { + t(mat)[upper.tri(mat)] + } else { + mat[upper.tri(mat)] + } } - } - test_symmetric <- function(d, e) { - l <- invWR1d(d = d, nu = e) - r <- l %*% t(l) - expect_equal(get_tri(r, "lower"), get_tri(r, "upper")) - } - for (d in d_vals) { - for (nu in nu_vals) { - test_symmetric(d, nu) - } - } - }) + test_symmetric <- function(d, e) { + l <- invWR1d(d = d, nu = e) + r <- l %*% t(l) + expect_equal(get_tri(r, "lower"), get_tri(r, "upper")) + } + for (d in d_vals) { + for (nu in nu_vals) { + test_symmetric(d, nu) + } + } + }) - test_that("invWR1d gives error if nu < d-1", { - err_string <- "'nu' must be greater than 'd'-1" - for (d in d_vals) { - for (nu in c(-1, 1)) { - expect_error(invWR1d(d = d, nu = nu), err_string) - } - } - }) -} + test_that("invWR1d gives error if nu < d-1", { + err_string <- "'nu' must be greater than 'd'-1" + for (d in d_vals) { + for (nu in c(-1, 1)) { + expect_error(invWR1d(d = d, nu = nu), err_string) + } + } + }) + } +}) diff --git a/tests/testthat/test-rxFix.R b/tests/testthat/test-rxFix.R index 5afe3e6fb..d613ffd27 100644 --- a/tests/testthat/test-rxFix.R +++ b/tests/testthat/test-rxFix.R @@ -1,133 +1,135 @@ -test_that("rxFix", { +rxTest({ + test_that("rxFix", { - One.comp.transit.allo <- function() { - ini({ - # Where initial conditions/variables are specified - lktr <- log(1.15) #log k transit (/h) - lcl <- log(0.15) #log Cl (L/hr) - lv <- log(7) #log V (L) - ALLC <- fix(0.75) #allometric exponent cl - ALLV <- fix(1.00) #allometric exponent v - prop.err <- 0.15 #proportional error (SD/mean) - add.err <- 0.6 #additive error (mg/L) - eta.ktr ~ 0.5 - eta.cl ~ 0.1 - eta.v ~ 0.1 - }) - model({ - #Allometric scaling on weight - cl <- exp(lcl + eta.cl + ALLC * logWT70) - v <- exp(lv + eta.v + ALLV * logWT70) - ktr <- exp(lktr + eta.ktr) - # RxODE-style differential equations are supported - d/dt(depot) = -ktr * depot - d/dt(central) = ktr * trans - (cl/v) * central - d/dt(trans) = ktr * depot - ktr * trans - ## Concentration is calculated - cp = central/v - # And is assumed to follow proportional and additive error - cp ~ prop(prop.err) + add(add.err) - }) - } + One.comp.transit.allo <- function() { + ini({ + # Where initial conditions/variables are specified + lktr <- log(1.15) #log k transit (/h) + lcl <- log(0.15) #log Cl (L/hr) + lv <- log(7) #log V (L) + ALLC <- fix(0.75) #allometric exponent cl + ALLV <- fix(1.00) #allometric exponent v + prop.err <- 0.15 #proportional error (SD/mean) + add.err <- 0.6 #additive error (mg/L) + eta.ktr ~ 0.5 + eta.cl ~ 0.1 + eta.v ~ 0.1 + }) + model({ + #Allometric scaling on weight + cl <- exp(lcl + eta.cl + ALLC * logWT70) + v <- exp(lv + eta.v + ALLV * logWT70) + ktr <- exp(lktr + eta.ktr) + # RxODE-style differential equations are supported + d/dt(depot) = -ktr * depot + d/dt(central) = ktr * trans - (cl/v) * central + d/dt(trans) = ktr * depot - ktr * trans + ## Concentration is calculated + cp = central/v + # And is assumed to follow proportional and additive error + cp ~ prop(prop.err) + add(add.err) + }) + } - tmp <- rxFixPop(One.comp.transit.allo) + tmp <- rxFixPop(One.comp.transit.allo) - expect_equal(tmp$theta, - c(lktr = 0.139761942375159, lcl = -1.89711998488588, lv = 1.94591014905531, - prop.err = 0.15, add.err = 0.6)) + expect_equal(tmp$theta, + c(lktr = 0.139761942375159, lcl = -1.89711998488588, lv = 1.94591014905531, + prop.err = 0.15, add.err = 0.6)) - tmp2 <- rxFixPop(tmp) + tmp2 <- rxFixPop(tmp) - expect_equal(tmp2$theta, - c(lktr = 0.139761942375159, lcl = -1.89711998488588, lv = 1.94591014905531, - prop.err = 0.15, add.err = 0.6)) + expect_equal(tmp2$theta, + c(lktr = 0.139761942375159, lcl = -1.89711998488588, lv = 1.94591014905531, + prop.err = 0.15, add.err = 0.6)) - tmp3 <- rxFixPop(tmp2, returnNull = TRUE) + tmp3 <- rxFixPop(tmp2, returnNull = TRUE) - expect_true(is.null(tmp3)) + expect_true(is.null(tmp3)) - nlmixr_threecmt_mm_no_add_wtcl_pdtg_kout_delay2 <- function() { - ini({ - tf_sc <- log(999) - tf_infilt <- log(999) - tka_sc <- log(999) - tka_infilt <- log(999) - tcl_low <- log(999) - tcl_high <- log(999) - tcl_c50 <- log(3000) - e_wt_cl <- fixed(999) - tv <- log(999) - tq1 <- log(999) - tvp1 <- log(10) - tq2 <- log(999) - tvp2 <- log(20) - eta_cl~999 - eta_v~999 - prop_err <- 999 - tg_bl <- log(999) - eta_tg_bl~999 - tg_kel <- log(999) - tg_ec50 <- log(5000) - tg_emax_kel <- log(2) - ktr_tg <- log(999) - prop_err_tg <- 999 - }) - model({ - # PK setup - f_sc <- exp(tf_sc) - f_infilt <- exp(tf_infilt) - ka_sc <- exp(tka_sc) - ka_infilt <- exp(tka_infilt) - cl_low <- exp(tcl_low + eta_cl)*(WEIGHT_BL/85)^e_wt_cl - cl_high <- exp(tcl_high + eta_cl)*(WEIGHT_BL/85)^e_wt_cl - cl_c50 <- exp(tcl_c50) - v <- exp(tv + eta_v) - q1 <- exp(tq1) - vp1 <- exp(tvp1) - q2 <- exp(tq2) - vp2 <- exp(tvp2) - # PK micro-parameters - ke_low <- cl_low/v - ke_high <- cl_high/v - kc_p1 <- q1/v - kp1_c <- q1/vp1 - kc_p2 <- q2/v - kp2_c <- q2/vp2 - # TG setup - tgbl <- exp(tg_bl + eta_tg_bl) - kin_tg <- tgbl*exp(tg_kel) - ktr_TG <- exp(ktr_tg) - TG(0) <- tgbl - # differential equations - cp <- CENTRAL/v*1e3 # 1e3 is for unit conversion - ke <- ke_low + (ke_high - ke_low)*cp/(cp + cl_c50) - kout_tg <- exp(tg_kel) + exp(tg_emax_kel)*TG_TR/(TG_TR + exp(tg_ec50)) - d/dt(IVINFILT) = - ka_infilt * IVINFILT - d/dt(SC) = -ka_sc * SC - d/dt(CENTRAL) = ka_sc * SC + ka_infilt * IVINFILT - ke*CENTRAL - kc_p1*CENTRAL + kp1_c*P1 - kc_p2*CENTRAL + kp2_c*P2 - d/dt(P1) = kc_p1*CENTRAL - kp1_c*P1 - d/dt(P2) = kc_p2*CENTRAL - kp2_c*P2 - f(SC) <- f_sc - f(IVINFILT) <- f_infilt - # TG transit model - d/dt(TG_TR) = ktr_tg*cp - ktr_tg*TG_TR - d/dt(TG) = kin_tg - kout_tg*TG - # Residual error models - cp ~ prop(prop_err) - TG ~ prop(prop_err_tg) - }) - } + nlmixr_threecmt_mm_no_add_wtcl_pdtg_kout_delay2 <- function() { + ini({ + tf_sc <- log(999) + tf_infilt <- log(999) + tka_sc <- log(999) + tka_infilt <- log(999) + tcl_low <- log(999) + tcl_high <- log(999) + tcl_c50 <- log(3000) + e_wt_cl <- fixed(999) + tv <- log(999) + tq1 <- log(999) + tvp1 <- log(10) + tq2 <- log(999) + tvp2 <- log(20) + eta_cl~999 + eta_v~999 + prop_err <- 999 + tg_bl <- log(999) + eta_tg_bl~999 + tg_kel <- log(999) + tg_ec50 <- log(5000) + tg_emax_kel <- log(2) + ktr_tg <- log(999) + prop_err_tg <- 999 + }) + model({ + # PK setup + f_sc <- exp(tf_sc) + f_infilt <- exp(tf_infilt) + ka_sc <- exp(tka_sc) + ka_infilt <- exp(tka_infilt) + cl_low <- exp(tcl_low + eta_cl)*(WEIGHT_BL/85)^e_wt_cl + cl_high <- exp(tcl_high + eta_cl)*(WEIGHT_BL/85)^e_wt_cl + cl_c50 <- exp(tcl_c50) + v <- exp(tv + eta_v) + q1 <- exp(tq1) + vp1 <- exp(tvp1) + q2 <- exp(tq2) + vp2 <- exp(tvp2) + # PK micro-parameters + ke_low <- cl_low/v + ke_high <- cl_high/v + kc_p1 <- q1/v + kp1_c <- q1/vp1 + kc_p2 <- q2/v + kp2_c <- q2/vp2 + # TG setup + tgbl <- exp(tg_bl + eta_tg_bl) + kin_tg <- tgbl*exp(tg_kel) + ktr_TG <- exp(ktr_tg) + TG(0) <- tgbl + # differential equations + cp <- CENTRAL/v*1e3 # 1e3 is for unit conversion + ke <- ke_low + (ke_high - ke_low)*cp/(cp + cl_c50) + kout_tg <- exp(tg_kel) + exp(tg_emax_kel)*TG_TR/(TG_TR + exp(tg_ec50)) + d/dt(IVINFILT) = - ka_infilt * IVINFILT + d/dt(SC) = -ka_sc * SC + d/dt(CENTRAL) = ka_sc * SC + ka_infilt * IVINFILT - ke*CENTRAL - kc_p1*CENTRAL + kp1_c*P1 - kc_p2*CENTRAL + kp2_c*P2 + d/dt(P1) = kc_p1*CENTRAL - kp1_c*P1 + d/dt(P2) = kc_p2*CENTRAL - kp2_c*P2 + f(SC) <- f_sc + f(IVINFILT) <- f_infilt + # TG transit model + d/dt(TG_TR) = ktr_tg*cp - ktr_tg*TG_TR + d/dt(TG) = kin_tg - kout_tg*TG + # Residual error models + cp ~ prop(prop_err) + TG ~ prop(prop_err_tg) + }) + } - tmp <- rxFixPop(nlmixr_threecmt_mm_no_add_wtcl_pdtg_kout_delay2) + tmp <- rxFixPop(nlmixr_threecmt_mm_no_add_wtcl_pdtg_kout_delay2) - expect_equal(tmp$theta, - c(tf_sc = 6.90675477864855, tf_infilt = 6.90675477864855, tka_sc = 6.90675477864855, - tka_infilt = 6.90675477864855, tcl_low = 6.90675477864855, tcl_high = 6.90675477864855, - tcl_c50 = 8.00636756765025, tv = 6.90675477864855, tq1 = 6.90675477864855, - tvp1 = 2.30258509299405, tq2 = 6.90675477864855, tvp2 = 2.99573227355399, - prop_err = 999, tg_bl = 6.90675477864855, tg_kel = 6.90675477864855, - tg_ec50 = 8.51719319141624, tg_emax_kel = 0.693147180559945, - ktr_tg = 6.90675477864855, prop_err_tg = 999)) + expect_equal(tmp$theta, + c(tf_sc = 6.90675477864855, tf_infilt = 6.90675477864855, tka_sc = 6.90675477864855, + tka_infilt = 6.90675477864855, tcl_low = 6.90675477864855, tcl_high = 6.90675477864855, + tcl_c50 = 8.00636756765025, tv = 6.90675477864855, tq1 = 6.90675477864855, + tvp1 = 2.30258509299405, tq2 = 6.90675477864855, tvp2 = 2.99573227355399, + prop_err = 999, tg_bl = 6.90675477864855, tg_kel = 6.90675477864855, + tg_ec50 = 8.51719319141624, tg_emax_kel = 0.693147180559945, + ktr_tg = 6.90675477864855, prop_err_tg = 999)) + }) }) diff --git a/tests/testthat/test-rxUiDeparse.R b/tests/testthat/test-rxUiDeparse.R new file mode 100644 index 000000000..284384511 --- /dev/null +++ b/tests/testthat/test-rxUiDeparse.R @@ -0,0 +1,13 @@ +test_that("rxUiDeparse()", { + + rxUiDeparse(rxControl(), "a") + expect_equal(rxUiDeparse(rxControl(), "a"), + str2lang("a <- rxControl()")) + + expect_equal(rxUiDeparse(rxControl(covsInterpolation="linear", method="dop853", + naInterpolation="nocb", keepInterpolation="nocb", sigmaXform="variance", + omegaXform="variance", returnType="data.frame", sumType="fsum", prodType="logify", + sensType="central"), "a"), + str2lang("a <- rxControl(method = \"dop853\", covsInterpolation = \"linear\", returnType = \"data.frame\", sigmaXform = \"variance\", sumType = \"fsum\", sensType = \"central\", naInterpolation = \"nocb\", keepInterpolation = \"nocb\")")) + +}) diff --git a/tests/testthat/test-rxode-issue-349.R b/tests/testthat/test-rxode-issue-349.R index f23f3be0c..22a636ca1 100644 --- a/tests/testthat/test-rxode-issue-349.R +++ b/tests/testthat/test-rxode-issue-349.R @@ -1,14 +1,15 @@ rxTest({ test_that("Zero variances; RxODE#299", { + mod <- rxode2({ eff(0) <- 1 C2 <- centr / V2 C3 <- peri / V3 CL <- TCl * exp(eta.Cl) ## This is coded as a variable in the model - d / dt(depot) <- -KA * depot - d / dt(centr) <- KA * depot - CL * C2 - Q * C2 + Q * C3 - d / dt(peri) <- Q * C2 - Q * C3 - d / dt(eff) <- Kin - Kout * (1 - C2 / (EC50 + C2)) * eff + d/dt(depot) <- -KA * depot + d/dt(centr) <- KA * depot - CL * C2 - Q * C2 + Q * C3 + d/dt(peri) <- Q * C2 - Q * C3 + d/dt(eff) <- Kin - Kout * (1 - C2 / (EC50 + C2)) * eff e <- eff + eff.err cp <- centr * (1 + cp.err) }) diff --git a/tests/testthat/test-safeZero.R b/tests/testthat/test-safeZero.R new file mode 100644 index 000000000..be32cd749 --- /dev/null +++ b/tests/testthat/test-safeZero.R @@ -0,0 +1,33 @@ +test_that("safeZero solving", { + + + m <- rxode2({ + nan0 = 0/0 + nanLog = log(-1) + nanPow = 0^-1 + rPow = 0^-1.5 + }) + + et <- et(1) + + unsafe <- rxSolve(m, et, safeZero=FALSE, safePow=FALSE, safeLog=FALSE, useStdPow = TRUE) + expect_true(is.nan(unsafe$nan0)) + expect_true(is.nan(unsafe$nanLog)) + expect_false(is.finite(unsafe$nanPow)) + expect_false(is.finite(unsafe$rPow)) + + safe <- rxSolve(m, et, safeZero=TRUE, safePow=TRUE, safeLog=TRUE, useStdPow=FALSE) + + expect_false(is.nan(safe$nan0)) + expect_false(is.nan(safe$nanLog)) + expect_true(is.finite(safe$nanPow)) + expect_true(is.finite(safe$rPow)) + + safe <- rxSolve(m, et, safeZero=TRUE, safePow=FALSE, safeLog=TRUE, useStdPow=FALSE) + + expect_false(is.na(safe$nan0)) + expect_false(is.na(safe$nanLog)) + expect_false(is.finite(safe$nanPow)) + expect_false(is.finite(safe$rPow)) + +}) diff --git a/tests/testthat/test-statePropDf.R b/tests/testthat/test-statePropDf.R new file mode 100644 index 000000000..3de47e07c --- /dev/null +++ b/tests/testthat/test-statePropDf.R @@ -0,0 +1,88 @@ +test_that("statePropDf test", { + + m1 <- function() { + ini({ + KA <- 2.94E-01 + CL <- 1.86E+01 + V2 <- 4.02E+01 + Q <- 1.05E+01 + V3 <- 2.97E+02 + Kin <- 1 + Kout <- 1 + EC50 <- 200 + ## Added modeled bioavaiblity, duration and rate + fdepot <- 1 + durDepot <- 8 + rateDepot <- 1250 + }) + model({ + C2 <- centr/V2 + C3 <- peri/V3 + d/dt(depot) <- -KA*depot + depot(0)<- 0 + f(depot) <- fdepot + dur(depot) <- durDepot + rate(depot) <- rateDepot + d/dt(centr) <- KA*depot - CL*C2 - Q*C2 + Q*C3 + d/dt(peri) <- Q*C2 - Q*C3 + d/dt(eff) <- Kin - Kout*(1-C2/(EC50+C2))*eff + eff(0) <- 1 + }) + } + + m1 <- m1() + + e1 <- data.frame(Compartment = c("depot", "depot", "depot", "depot", "eff"), + Property=c("ini", "f", "rate", "dur", "ini")) + + expect_equal(m1$statePropDf,e1) + + m2 <- m1 |> model(-depot(0)) + + .noRow <- function(d) { + row.names(d) <- NULL + d + } + + expect_equal(m2$statePropDf, + .noRow(e1[-which(e1$Compartment == "depot" & e1$Property == "ini"), ])) + + m2 <- m1 |> model(-f(depot)) + + expect_equal(m2$statePropDf, + .noRow(e1[-which(e1$Compartment == "depot" & e1$Property == "f"), ])) + + m2 <- m1 |> model(-dur(depot)) + + expect_equal(m2$statePropDf, + .noRow(e1[-which(e1$Compartment == "depot" & e1$Property == "dur"), ])) + + m2 <- m1 |> model(-rate(depot)) + + expect_equal(m2$statePropDf, + .noRow(e1[-which(e1$Compartment == "depot" & e1$Property == "rate"), ])) + + + + m1 <- function() { + ini({ + KA <- 2.94E-01 + CL <- 1.86E+01 + V2 <- 4.02E+01 + Q <- 1.05E+01 + V3 <- 2.97E+02 + }) + model({ + C2 <- centr/V2 + C3 <- peri/V3 + d/dt(depot) <- -KA*depot + d/dt(centr) <- KA*depot - CL*C2 - Q*C2 + Q*C3 + d/dt(peri) <- Q*C2 - Q*C3 + }) + } + + m2 <- m1() + expect_equal(m2$statePropDf, + NULL) + +}) diff --git a/tests/testthat/test-symmetric.R b/tests/testthat/test-symmetric.R index 0ef35f1eb..112d7da55 100644 --- a/tests/testthat/test-symmetric.R +++ b/tests/testthat/test-symmetric.R @@ -34,7 +34,7 @@ rxTest({ Gp(0) = kcp*Gss*Vg/kpc; Ie(0) = Iss; I(0) = Iss*Vi; - Isec(0) = Iss*ki*Vi; + Isec_0 = Iss*ki*Vi; d/dt(depot) = -absg; d/dt(trn) = absg - ka*trn; diff --git a/tests/testthat/test-tad.R b/tests/testthat/test-tad.R index 2d96d4a41..bbb7ebfb9 100644 --- a/tests/testthat/test-tad.R +++ b/tests/testthat/test-tad.R @@ -346,32 +346,7 @@ rxTest({ }) test_that("test parsing of ode", { - suppressMessages(withr::with_options( - # Default option set - list(rxode2.syntax.require.ode.first=NULL), - expect_error(rxode2({ - KA <- 2.94E-01 - CL <- 1.86E+01 - V2 <- 4.02E+01 - Q <- 1.05E+01 - V3 <- 2.97E+02 - Kin <- 1 - Kout <- 1 - EC50 <- 200 - C2 <- centr / V2 - C3 <- peri / V3 - ## error in capturing early - f <- tad(eff) - d / dt(depot) <- -KA * depot - d / dt(centr) <- KA * depot - CL * C2 - Q * C2 + Q * C3 - d / dt(peri) <- Q * C2 - Q * C3 - d / dt(eff) <- Kin - Kout * (1 - C2 / (EC50 + C2)) * eff - })) - )) - ## now change the option - withr::with_options( - list(rxode2.syntax.require.ode.first = FALSE), expect_error(rxode2({ KA <- 2.94E-01 CL <- 1.86E+01 @@ -390,7 +365,6 @@ rxTest({ d / dt(peri) <- Q * C2 - Q * C3 d / dt(eff) <- Kin - Kout * (1 - C2 / (EC50 + C2)) * eff }), NA) - ) }) # context("tad family of functions with linCmt()") diff --git a/tests/testthat/test-udf.R b/tests/testthat/test-udf.R index 4fbce5784..9dfe891e3 100644 --- a/tests/testthat/test-udf.R +++ b/tests/testthat/test-udf.R @@ -361,4 +361,284 @@ rxTest({ }) +}) + + +test_that("udf type 2 (that changes ui models upon parsing)", { + + expect_error(rxModelVars("a <- linMod(x, 3)"), NA) + expect_error(rxModelVars("a <- linMod(x, 3, b)")) + expect_error(rxModelVars("a <- linMod(x)")) + expect_error(rxModelVars("a <- linMod()")) + + f <- rxode2({ + a <- linMod(x, 3) + }) + + e <- et(1:10) + + expect_error(rxSolve(f, e, c(x=2)), "ui user function") + + # Test a linear model construction + + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linMod(time, 3) + b <- d + }) + } + + tmp <- f() + + expect_equal(tmp$iniDf$name, + c("d", "rx.linMod.time1a", "rx.linMod.time1b", "rx.linMod.time1c", + "rx.linMod.time1d")) + + expect_equal(modelExtract(tmp, a), + "a <- (rx.linMod.time1a + rx.linMod.time1b * time + rx.linMod.time1c * time^2 + rx.linMod.time1d * time^3)") + + # Test a linear model construction without an intercept + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linMod0(time, 3) + d + }) + } + + tmp <- f() + + expect_equal(tmp$iniDf$name, + c("d", "rx.linMod.time1a", "rx.linMod.time1b", "rx.linMod.time1c")) + + + expect_equal(modelExtract(tmp, a), + "a <- (rx.linMod.time1a * time + rx.linMod.time1b * time^2 + rx.linMod.time1c * time^3) + d") + + # Now test the use of 2 linear models in the UI + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linMod(time, 3) + b <- linMod(time, 3) + c <- d + }) + } + + tmp <- f() + + expect_equal(tmp$iniDf$name, + c("d", "rx.linMod.time1a", "rx.linMod.time1b", "rx.linMod.time1c", "rx.linMod.time1d", + "rx.linMod.time2a", "rx.linMod.time2b", "rx.linMod.time2c", "rx.linMod.time2d")) + + expect_equal(modelExtract(tmp, a), + "a <- (rx.linMod.time1a + rx.linMod.time1b * time + rx.linMod.time1c * time^2 + rx.linMod.time1d * time^3)") + + expect_equal(modelExtract(tmp, b), + "b <- (rx.linMod.time2a + rx.linMod.time2b * time + rx.linMod.time2c * time^2 + rx.linMod.time2d * time^3)") + + + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linModB(time, 3) + b <- d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, rx.linMod.time.f1), + "rx.linMod.time.f1 <- rx.linMod.time1a + rx.linMod.time1b * time + rx.linMod.time1c * time^2 + rx.linMod.time1d * time^3") + + expect_equal(modelExtract(tmp, a), + "a <- rx.linMod.time.f1") + + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linModB0(time, 3) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, rx.linMod.time.f1), + "rx.linMod.time.f1 <- rx.linMod.time1a * time + rx.linMod.time1b * time^2 + rx.linMod.time1c * time^3") + + expect_equal(modelExtract(tmp, a), + "a <- rx.linMod.time.f1 + d") + + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linModA(time, 1) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, rx.linMod.time.f1), + "rx.linMod.time.f1 <- rx.linMod.time1a + rx.linMod.time1b * time") + + expect_equal(modelExtract(tmp, a), + "a <- 0 + d") + + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linModA0(time, 1) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, rx.linMod.time.f1), + "rx.linMod.time.f1 <- rx.linMod.time1a * time") + + expect_equal(modelExtract(tmp, a), + "a <- 0 + d") + + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linMod(power=3, variable="x") + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, a), + "a <- (rx.linMod.x1a + rx.linMod.x1b * x + rx.linMod.x1c * x^2 + rx.linMod.x1d * x^3) + d") + + expect_false(tmp$uiUseData) + + + ## Formula interface + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linMod0(dv~x^3) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, a), + "a <- linModD0(x, 3, dv) + d") + expect_true(tmp$uiUseData) + + ## Formula interface + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linMod0(~x^3) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, a), + "a <- (rx.linMod.x1a * x + rx.linMod.x1b * x^2 + rx.linMod.x1c * x^3) + d") + + ## Formula interface + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linMod0(~x^6) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, a), + "a <- (rx.linMod.x1a * x + rx.linMod.x1b * x^2 + rx.linMod.x1c * x^3 + rx.linMod.x1d * x^4 + rx.linMod.x1e * x^5 + rx.linMod.x1f * x^6) + d") + + + # This checks to make sure that the variables are not in the model + # before adding them + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linModM0(~x^6) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, a), + "a <- (x1a * x + x1b * x^2 + x1c * x^3 + x1d * x^4 + x1e * x^5 + x1f * x^6) + d") + + + f <- function() { + ini({ + d <- 4 + }) + model({ + a <- linModM(~x^6) + d + }) + } + + tmp <- f() + + expect_equal(modelExtract(tmp, a), + "a <- (x1a + x1b * x + x1c * x^2 + x1d * x^3 + x1e * x^4 + x1f * x^5 + x1g * x^6) + d") + + rxWithSeed(42, { + + q <- seq(from=0, to=20, by=0.1) + + y <- 500 + 42*q^2 + 0.4 * (q-10)^3 + + df <- data.frame(q=q, y=y) + + f <- function() { + model({ + a <- linMod(y~q^3) + }) + } + + f <- f() + + expect_equal(modelExtract(f, a), + "a <- linModD(q, 3, y)") + + rxUdfUiData(df) + + try({ + if (f$uiUseData) { + f <- rxode2(as.function(f)) + expect_false(any(f$theta == 0)) + } + }) + rxUdfUiData(NULL) + }) + + + + }) diff --git a/tests/testthat/test-ui-piping.R b/tests/testthat/test-ui-piping.R index 2107aa0f1..7ce5bfc71 100644 --- a/tests/testthat/test-ui-piping.R +++ b/tests/testthat/test-ui-piping.R @@ -1,1146 +1,1190 @@ -testPipeQuote <- function(..., envir=parent.frame(), iniDf = NULL) { - rxUnloadAll() - gc() - .quoteCallInfoLines(match.call(expand.dots = TRUE)[-1], envir=envir, iniDf=iniDf) -} - - rxTest({ + testPipeQuote <- function(..., envir=parent.frame(), iniDf = NULL) { + rxUnloadAll() + gc() + .quoteCallInfoLines(match.call(expand.dots = TRUE)[-1], envir=envir, iniDf=iniDf) + } - test_that("nse evaluation", { - - tmp <- "d/dt(depot)" - expect_equal(testPipeQuote(tmp), - list(quote(d/dt(depot)))) - - - t <- c("-d/dt(peripheral1)", "-d/dt(peripheral2)") - expect_equal(testPipeQuote(t), - list(quote(-d/dt(peripheral1)), - quote(-d/dt(peripheral2)))) - - t <- c(a="x", b="y") - - expect_equal(testPipeQuote(t), - list(quote(a <- x), quote(b <- y))) + rxTest({ + test_that("nse evaluation", { - tmp <- list(tmp="d/dt(depot)") + tmp <- "d/dt(depot)" + expect_equal(testPipeQuote(tmp), + list(quote(d/dt(depot)))) - expect_equal(testPipeQuote(tmp$tmp), - list(quote(d/dt(depot)))) - tmp <- list(tmp=list(tmp="d/dt(depot)")) + t <- c("-d/dt(peripheral1)", "-d/dt(peripheral2)") + expect_equal(testPipeQuote(t), + list(quote(-d/dt(peripheral1)), + quote(-d/dt(peripheral2)))) - expect_equal(testPipeQuote(tmp$tmp$tmp), - list(quote(d/dt(depot)))) - }) + t <- c(a="x", b="y") - test_that("equivalent drop statements", { - - expect_equal(.changeDropNullLine(quote(a <- NULL)), - quote(-a)) - expect_equal(.changeDropNullLine(quote(a ~ NULL)), - quote(-a)) - expect_equal(.changeDropNullLine(str2lang("a = NULL")), - quote(-a)) - - expect_equal(.changeDropNullLine(quote(d/dt(a) <- NULL)), - quote(-d/dt(a))) - expect_equal(.changeDropNullLine(quote(d/dt(a) ~ NULL)), - quote(-d/dt(a))) - expect_equal(.changeDropNullLine(str2lang("d/dt(a) = NULL")), - quote(-d/dt(a))) - - expect_equal(.changeDropNullLine(quote(lag(a) <- NULL)), - quote(-lag(a))) - expect_equal(.changeDropNullLine(quote(lag(a) ~ NULL)), - quote(-lag(a))) - expect_equal(.changeDropNullLine(str2lang("lag(a) = NULL")), - quote(-lag(a))) - - expect_equal(.changeDropNullLine(quote(alag(a) <- NULL)), - quote(-alag(a))) - expect_equal(.changeDropNullLine(quote(alag(a) ~ NULL)), - quote(-alag(a))) - expect_equal(.changeDropNullLine(str2lang("alag(a) = NULL")), - quote(-alag(a))) - - expect_equal(.changeDropNullLine(quote(F(a) <- NULL)), - quote(-F(a))) - expect_equal(.changeDropNullLine(quote(F(a) ~ NULL)), - quote(-F(a))) - expect_equal(.changeDropNullLine(str2lang("F(a) = NULL")), - quote(-F(a))) - - expect_equal(.changeDropNullLine(quote(f(a) <- NULL)), - quote(-f(a))) - expect_equal(.changeDropNullLine(quote(f(a) ~ NULL)), - quote(-f(a))) - expect_equal(.changeDropNullLine(str2lang("f(a) = NULL")), - quote(-f(a))) - - expect_equal(.changeDropNullLine(quote(rate(a) <- NULL)), - quote(-rate(a))) - expect_equal(.changeDropNullLine(quote(rate(a) ~ NULL)), - quote(-rate(a))) - expect_equal(.changeDropNullLine(str2lang("rate(a) = NULL")), - quote(-rate(a))) - - expect_equal(.changeDropNullLine(quote(dur(a) <- NULL)), - quote(-dur(a))) - expect_equal(.changeDropNullLine(quote(dur(a) ~ NULL)), - quote(-dur(a))) - expect_equal(.changeDropNullLine(str2lang("dur(a) = NULL")), - quote(-dur(a))) - - expect_equal(.changeDropNullLine(quote(a(0) <- NULL)), - quote(-a(0))) - expect_equal(.changeDropNullLine(quote(a(0) ~ NULL)), - quote(-a(0))) - expect_equal(.changeDropNullLine(str2lang("a(0) = NULL")), - quote(-a(0))) + expect_equal(testPipeQuote(t), + list(quote(a <- x), quote(b <- y))) - }) - test_that("test fix/unfix for eta", { - expect_equal(testPipeQuote(a~fix), - list(quote(a<-fix))) - expect_equal(testPipeQuote(a~unfix), - list(quote(a<-unfix))) - }) - test_that("test as formula", { - expect_equal(testPipeQuote(as.formula(a~b)), - list(quote(a~b))) - }) + tmp <- list(tmp="d/dt(depot)") - test_that("test of standard quoting of piping arguments", { - expect_equal(testPipeQuote(-ka, tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - cl = exp(tcl + eta.cl) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, "tv10=3"), list(quote(-ka), - quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(cl <- exp(tcl + eta.cl)), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(tv10 <- 3))) - - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2))) - - expect_equal(testPipeQuote({ - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2), - list(quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2))) - - # Test c() - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, c(tka=1, tv=3, tcl=4)), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(tka <- 1), - quote(tv <- 3), - quote(tcl <- 4)) - ) + expect_equal(testPipeQuote(tmp$tmp), + list(quote(d/dt(depot)))) - # test list() - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, list(tka=1, tv=3, tcl=4)), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(tka <- 1), - quote(tv <- 3), - quote(tcl <- 4)) - ) + tmp <- list(tmp=list(tmp="d/dt(depot)")) - .tmp <- list(tcl = 3, tv = 4) - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, .tmp), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(tcl <- 3), - quote(tv <- 4)) - ) + expect_equal(testPipeQuote(tmp$tmp$tmp), + list(quote(d/dt(depot)))) + }) - .tmp <- c(tcl = 3, tv = 4) - - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, .tmp), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(tcl <- 3), - quote(tv <- 4)) - ) + test_that("equivalent drop statements", { + + expect_equal(.changeDropNullLine(quote(a <- NULL)), + quote(-a)) + expect_equal(.changeDropNullLine(quote(a ~ NULL)), + quote(-a)) + expect_equal(.changeDropNullLine(str2lang("a = NULL")), + quote(-a)) + + expect_equal(.changeDropNullLine(quote(d/dt(a) <- NULL)), + quote(-d/dt(a))) + expect_equal(.changeDropNullLine(quote(d/dt(a) ~ NULL)), + quote(-d/dt(a))) + expect_equal(.changeDropNullLine(str2lang("d/dt(a) = NULL")), + quote(-d/dt(a))) + + expect_equal(.changeDropNullLine(quote(lag(a) <- NULL)), + quote(-lag(a))) + expect_equal(.changeDropNullLine(quote(lag(a) ~ NULL)), + quote(-lag(a))) + expect_equal(.changeDropNullLine(str2lang("lag(a) = NULL")), + quote(-lag(a))) + + expect_equal(.changeDropNullLine(quote(alag(a) <- NULL)), + quote(-alag(a))) + expect_equal(.changeDropNullLine(quote(alag(a) ~ NULL)), + quote(-alag(a))) + expect_equal(.changeDropNullLine(str2lang("alag(a) = NULL")), + quote(-alag(a))) + + expect_equal(.changeDropNullLine(quote(F(a) <- NULL)), + quote(-F(a))) + expect_equal(.changeDropNullLine(quote(F(a) ~ NULL)), + quote(-F(a))) + expect_equal(.changeDropNullLine(str2lang("F(a) = NULL")), + quote(-F(a))) + + expect_equal(.changeDropNullLine(quote(f(a) <- NULL)), + quote(-f(a))) + expect_equal(.changeDropNullLine(quote(f(a) ~ NULL)), + quote(-f(a))) + expect_equal(.changeDropNullLine(str2lang("f(a) = NULL")), + quote(-f(a))) + + expect_equal(.changeDropNullLine(quote(rate(a) <- NULL)), + quote(-rate(a))) + expect_equal(.changeDropNullLine(quote(rate(a) ~ NULL)), + quote(-rate(a))) + expect_equal(.changeDropNullLine(str2lang("rate(a) = NULL")), + quote(-rate(a))) + + expect_equal(.changeDropNullLine(quote(dur(a) <- NULL)), + quote(-dur(a))) + expect_equal(.changeDropNullLine(quote(dur(a) ~ NULL)), + quote(-dur(a))) + expect_equal(.changeDropNullLine(str2lang("dur(a) = NULL")), + quote(-dur(a))) + + expect_equal(.changeDropNullLine(quote(a(0) <- NULL)), + quote(-a(0))) + expect_equal(.changeDropNullLine(quote(a(0) ~ NULL)), + quote(-a(0))) + expect_equal(.changeDropNullLine(str2lang("a(0) = NULL")), + quote(-a(0))) - .tmp <- quote({ - ka = exp(tka) }) - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, .tmp), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(ka <- exp(tka))) - ) - - .tmp <- quote(ka <- 8) - - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, .tmp), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(ka <- 8)) - ) + test_that("test fix/unfix for eta", { + expect_equal(testPipeQuote(a~fix), + list(quote(a<-fix))) + expect_equal(testPipeQuote(a~unfix), + list(quote(a<-unfix))) + }) - .tmp <- quote(ka4 ~ 8) - - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, .tmp), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(ka4 ~ 8)) - ) + test_that("test as formula", { + expect_equal(testPipeQuote(as.formula(a~b)), + list(quote(a~b))) + }) - .tmp <- quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))) - - expect_equal(testPipeQuote(tka=0.5, { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.ka ~ 3, eta.ka ~ 3, - { - tv = 3 - tcl = 10 - eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) - }, eta.v ~ 0.2, .tmp), - list(quote(tka <- 0.5), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.ka ~ 3), - quote(eta.ka ~ 3), - quote(tv <- 3), - quote(tcl <- 10), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), - quote(eta.v ~ 0.2), - quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1))))) - ) - }) + test_that("test of standard quoting of piping arguments", { + expect_equal(testPipeQuote(-ka, tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + cl = exp(tcl + eta.cl) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, "tv10=3"), list(quote(-ka), + quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(cl <- exp(tcl + eta.cl)), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(tv10 <- 3))) + + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2))) + + expect_equal(testPipeQuote({ + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2), + list(quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2))) + + # Test c() + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, c(tka=1, tv=3, tcl=4)), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(tka <- 1), + quote(tv <- 3), + quote(tcl <- 4)) + ) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) - }) - } + # test list() + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, list(tka=1, tv=3, tcl=4)), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(tka <- 1), + quote(tv <- 3), + quote(tcl <- 4)) + ) - f <- rxode2(one.compartment) + .tmp <- list(tcl = 3, tv = 4) + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, .tmp), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(tcl <- 3), + quote(tv <- 4)) + ) - test_that("Model Line from Expression, assign", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + .tmp <- c(tcl = 3, tv = 4) + + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, .tmp), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(tcl <- 3), + quote(tv <- 4)) + ) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) + .tmp <- quote({ + ka = exp(tka) + }) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, .tmp), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(ka <- exp(tka))) + ) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) + .tmp <- quote(ka <- 8) + + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, .tmp), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(ka <- 8)) + ) - }) + .tmp <- quote(ka4 ~ 8) + + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, .tmp), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(ka4 ~ 8)) + ) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - f(depot) <- 3 - cp <- center / v - cp ~ add(add.err) + .tmp <- quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))) + + expect_equal(testPipeQuote(tka=0.5, { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.ka ~ 3, eta.ka ~ 3, + { + tv = 3 + tcl = 10 + eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1))) + }, eta.v ~ 0.2, .tmp), + list(quote(tka <- 0.5), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.ka ~ 3), + quote(eta.ka ~ 3), + quote(tv <- 3), + quote(tcl <- 10), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1)))), + quote(eta.v ~ 0.2), + quote(eta.v + eta.cl ~ unfix(cor(sd(0.3, 0.02, 0.1))))) + ) }) - } - f <- rxode2(one.compartment) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) + }) + } - test_that("Model Line from Expression, lower case f()", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + f <- rxode2(one.compartment) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), 6L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), 6L) + test_that("Model Line from Expression, assign", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) - }) + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - one.compartment <- function() { - ini({ - tka <- 0.45 - tcl <- 1 - tv <- 3.45 - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - F(depot) <- 3 - cp <- center / v - cp ~ add(add.err) }) - } - f <- rxode2(one.compartment) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + f(depot) <- 3 + cp <- center / v + cp ~ add(add.err) + }) + } + + f <- rxode2(one.compartment) - test_that("Model Line from Expression, upper case F()", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + test_that("Model Line from Expression, lower case f()", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), 6L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), 6L) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - }) + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - lag(depot) <- 3 - cp <- center / v - cp ~ add(add.err) }) - } - f <- rxode2(one.compartment) + one.compartment <- function() { + ini({ + tka <- 0.45 + tcl <- 1 + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + F(depot) <- 3 + cp <- center / v + cp ~ add(add.err) + }) + } - test_that("Model Line from Expression, lag()", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + f <- rxode2(one.compartment) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) + test_that("Model Line from Expression, upper case F()", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), 6L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), 6L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - }) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - alag(depot) <- 3 - cp <- center / v - cp ~ add(add.err) - }) - } - f <- rxode2(one.compartment) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + lag(depot) <- 3 + cp <- center / v + cp ~ add(add.err) + }) + } - test_that("Model Line from Expression, alag()", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + f <- rxode2(one.compartment) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) + test_that("Model Line from Expression, lag()", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), 6L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - }) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), 6L) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - rate(depot) <- 3 - cp <- center / v - cp ~ add(add.err) + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) }) - } - f <- rxode2(one.compartment) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + alag(depot) <- 3 + cp <- center / v + cp ~ add(add.err) + }) + } - test_that("Model Line from Expression, rate()", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + f <- rxode2(one.compartment) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) + test_that("Model Line from Expression, alag()", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), 6L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - }) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), 6L) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - dur(depot) <- 3 - cp <- center / v - cp ~ add(add.err) - }) - } - f <- rxode2(one.compartment) - - test_that("Model Line from Expression, dur()", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + rate(depot) <- 3 + cp <- center / v + cp ~ add(add.err) + }) + } - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) + f <- rxode2(one.compartment) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) + test_that("Model Line from Expression, rate()", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) - }) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) - # look at duplicate lines - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), 6L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d/dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) - }) - } - f <- rxode2(one.compartment) - - test_that("Model Line from Expression, duplicate d/dt(depot)", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + dur(depot) <- 3 + cp <- center / v + cp ~ add(add.err) + }) + } - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), NULL) + f <- rxode2(one.compartment) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -5L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -5L) + test_that("Model Line from Expression, dur()", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -5L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -5L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -5L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -5L) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) - }) + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), 6L) - # look at duplicate lines - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 + expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - f(depot) <- 3 - F(depot) <- 1 - cp <- center / v - cp ~ add(add.err) - }) - } - f <- rxode2(one.compartment) + # look at duplicate lines + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d/dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) + }) + } + + f <- rxode2(one.compartment) - test_that("Model Line from Expression, duplicate f(depot)", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + test_that("Model Line from Expression, duplicate d/dt(depot)", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), NULL) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), NULL) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), NULL) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -5L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -5L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -5L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -5L) - expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) - }) + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -5L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -5L) - # look at duplicate lag() - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - lag(depot) <- 3 - alag(depot) <- 1 - cp <- center / v - cp ~ add(add.err) + expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) }) - } - - f <- rxode2(one.compartment) - test_that("Model Line from Expression, duplicate f(depot)", { - expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) - expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) + # look at duplicate lines + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + f(depot) <- 3 + F(depot) <- 1 + cp <- center / v + cp ~ add(add.err) + }) + } - expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) + f <- rxode2(one.compartment) - expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), NULL) - expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), NULL) + test_that("Model Line from Expression, duplicate f(depot)", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), NULL) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), NULL) - expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) - expect_equal(.getModelLineFromExpression(quote(cp), f), 8L) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), -4L) - expect_equal(.getModelLineFromExpression(quote(cp), f, TRUE), 9L) - }) + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) + expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) }) - } - - f <- rxode2(one.compartment) - - testEst <- function(ui, par, lower, value, upper, fix=FALSE) { - uiForce <- suppressMessages(force(ui)) - .ini <- ui$iniDf - .w <- which(.ini$name == par) - expect_equal(length(.w), 1) - expect_equal(.ini$lower[.w], lower) - expect_equal(.ini$est[.w], value) - expect_equal(.ini$upper[.w], upper) - expect_equal(.ini$fix[.w], fix) - } - - test_that("simple ini piping, uncorrelated model", { - testEst(f, "tka", -Inf, 0.45, Inf, FALSE) - testEst(f %>% ini(tka=0.5), "tka", -Inf, 0.5, Inf, FALSE) - testEst(f %>% ini(tka=fix), "tka", -Inf, 0.45, Inf, TRUE) - testEst(f %>% ini(tka=c(0, 0.5)), "tka", 0, 0.5, Inf, FALSE) - testEst(f %>% ini(tka=c(0, 0.5, 1)), "tka", 0, 0.5, 1, FALSE) - - expect_error(f %>% ini(tka=c(0, 0.5, 1, 4)), "tka") - - expect_error(f %>% ini(tka=c(3,2,1)), "tka") + # look at duplicate lag() + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + lag(depot) <- 3 + alag(depot) <- 1 + cp <- center / v + cp ~ add(add.err) + }) + } - suppressMessages( - fFix <- f %>% ini(tka=fix) - ) - testEst(fFix, "tka", -Inf, 0.45, Inf, TRUE) - testEst(fFix %>% ini(tka=unfix), "tka", -Inf, 0.45, Inf, FALSE) - testEst(fFix %>% ini(tka=unfix(0.5)), "tka", -Inf, 0.5, Inf, FALSE) + f <- rxode2(one.compartment) - testEst(f %>% ini(eta.v ~ 0.2), "eta.v", -Inf, 0.2, Inf, FALSE) + test_that("Model Line from Expression, duplicate f(depot)", { + expect_equal(.getModelLineFromExpression(quote(ka), f), 1L) + expect_equal(.getModelLineFromExpression(quote(d/dt(depot)), f), 4L) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02, Inf, FALSE) + expect_equal(.getModelLineFromExpression(quote(f(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(F(depot)), f), -4L) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02*(sqrt(0.3)*sqrt(0.1)), Inf, FALSE) + expect_equal(.getModelLineFromExpression(quote(lag(depot)), f), NULL) + expect_equal(.getModelLineFromExpression(quote(alag(depot)), f), NULL) - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, TRUE) + expect_equal(.getModelLineFromExpression(quote(rate(depot)), f), -4L) + expect_equal(.getModelLineFromExpression(quote(dur(depot)), f), -4L) - # Test adding matrix directly + expect_equal(.getModelLineFromExpression(quote(not), f), NA_integer_) + expect_equal(.getModelLineFromExpression(quote(cp), f), 8L) - .omega <- lotri::lotri(eta.cl+eta.v~c(0.3, 0.02, 0.1)) + expect_equal(.getModelLineFromExpression(quote(cp), f, TRUE), 9L) + }) - testEst(f %>% ini(.omega), "eta.cl", -Inf, 0.3, Inf, FALSE) - testEst(f %>% ini(.omega), "eta.v", -Inf, 0.1, Inf, FALSE) - testEst(f %>% ini(.omega), "(eta.cl,eta.v)", -Inf, 0.02, Inf, FALSE) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) + }) + } - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, FALSE), - regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" - ) - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, FALSE), - regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" - ) - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, FALSE), - regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" - ) - }) + f <- rxode2(one.compartment) + + testEst <- function(ui, par, lower, value, upper, fix=FALSE) { + uiForce <- suppressMessages(force(ui)) + .ini <- ui$iniDf + .w <- which(.ini$name == par) + expect_equal(length(.w), 1) + expect_equal(.ini$lower[.w], lower) + expect_equal(.ini$est[.w], value) + expect_equal(.ini$upper[.w], upper) + expect_equal(.ini$fix[.w], fix) + } - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl + eta.v ~ sd(cor(0.3, - -0.7, 0.1)) - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) - }) - } + test_that("simple ini piping, uncorrelated model", { + testEst(f, "tka", -Inf, 0.45, Inf, FALSE) + testEst(f %>% ini(tka=0.5), "tka", -Inf, 0.5, Inf, FALSE) + testEst(f %>% ini(tka=fix), "tka", -Inf, 0.45, Inf, TRUE) - f <- rxode2(one.compartment) + testEst(f %>% ini(tka=c(0, 0.5)), "tka", 0, 0.5, Inf, FALSE) + testEst(f %>% ini(tka=c(0, 0.5, 1)), "tka", 0, 0.5, 1, FALSE) - test_that("simple ini piping, correlated model", { - testEst(f, "tka", -Inf, 0.45, Inf, FALSE) - testEst(f %>% ini(tka=0.5), "tka", -Inf, 0.5, Inf, FALSE) - testEst(f %>% ini(tka=fix), "tka", -Inf, 0.45, Inf, TRUE) + expect_error(f %>% ini(tka=c(0, 0.5, 1, 4)), "tka") - testEst(f %>% ini(tka=c(0, 0.5)), "tka", 0, 0.5, Inf, FALSE) - testEst(f %>% ini(tka=c(0, 0.5, 1)), "tka", 0, 0.5, 1, FALSE) + expect_error(f %>% ini(tka=c(3,2,1)), "tka") - expect_error(f %>% ini(tka=c(0, 0.5, 1, 4)), "tka") + suppressMessages( + fFix <- f %>% ini(tka=fix) + ) + testEst(fFix, "tka", -Inf, 0.45, Inf, TRUE) + testEst(fFix %>% ini(tka=unfix), "tka", -Inf, 0.45, Inf, FALSE) + testEst(fFix %>% ini(tka=unfix(0.5)), "tka", -Inf, 0.5, Inf, FALSE) + + testEst(f %>% ini(eta.v ~ 0.2), "eta.v", -Inf, 0.2, Inf, FALSE) + + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02, Inf, FALSE) + + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02*(sqrt(0.3)*sqrt(0.1)), Inf, FALSE) + + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, TRUE) + + # Test adding matrix directly + + .omega <- lotri::lotri(eta.cl+eta.v~c(0.3, 0.02, 0.1)) + + testEst(f %>% ini(.omega), "eta.cl", -Inf, 0.3, Inf, FALSE) + testEst(f %>% ini(.omega), "eta.v", -Inf, 0.1, Inf, FALSE) + testEst(f %>% ini(.omega), "(eta.cl,eta.v)", -Inf, 0.02, Inf, FALSE) + + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, FALSE), + regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" + ) + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, FALSE), + regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" + ) + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, FALSE), + regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" + ) + }) - expect_error(f %>% ini(tka=c(3,2,1)), "tka") + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl + eta.v ~ sd(cor(0.3, + -0.7, 0.1)) + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) + }) + } - suppressMessages( - fFix <- f %>% ini(tka=fix) - ) - testEst(fFix, "tka", -Inf, 0.45, Inf, TRUE) - testEst(fFix %>% ini(tka=unfix), "tka", -Inf, 0.45, Inf, FALSE) - testEst(fFix %>% ini(tka=unfix(0.5)), "tka", -Inf, 0.5, Inf, FALSE) + f <- rxode2(one.compartment) - testEst(f %>% ini(eta.v ~ 0.2), "eta.v", -Inf, 0.2, Inf, FALSE) + test_that("simple ini piping, correlated model", { + testEst(f, "tka", -Inf, 0.45, Inf, FALSE) + testEst(f %>% ini(tka=0.5), "tka", -Inf, 0.5, Inf, FALSE) + testEst(f %>% ini(tka=fix), "tka", -Inf, 0.45, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02, Inf, FALSE) + testEst(f %>% ini(tka=c(0, 0.5)), "tka", 0, 0.5, Inf, FALSE) + testEst(f %>% ini(tka=c(0, 0.5, 1)), "tka", 0, 0.5, 1, FALSE) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02*(sqrt(0.3)*sqrt(0.1)), Inf, FALSE) + expect_error(f %>% ini(tka=c(0, 0.5, 1, 4)), "tka") - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, TRUE) + expect_error(f %>% ini(tka=c(3,2,1)), "tka") - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, FALSE), - regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" - ) - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, FALSE), - regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" - ) - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, FALSE), - regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" + suppressMessages( + fFix <- f %>% ini(tka=fix) ) - }) - - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl + eta.v ~ fix(sd(cor(0.3, - -0.7, 0.1))) - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) + testEst(fFix, "tka", -Inf, 0.45, Inf, TRUE) + testEst(fFix %>% ini(tka=unfix), "tka", -Inf, 0.45, Inf, FALSE) + testEst(fFix %>% ini(tka=unfix(0.5)), "tka", -Inf, 0.5, Inf, FALSE) + + testEst(f %>% ini(eta.v ~ 0.2), "eta.v", -Inf, 0.2, Inf, FALSE) + + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02, Inf, FALSE) + + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02*(sqrt(0.3)*sqrt(0.1)), Inf, FALSE) + + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, TRUE) + + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, FALSE), + regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" + ) + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, FALSE), + regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" + ) + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, FALSE), + regexp="unfix.*eta.cl"), regexp="unfix.*eta.v" + ) }) - } - f <- rxode2(one.compartment) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl + eta.v ~ fix(sd(cor(0.3, + -0.7, 0.1))) + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) + }) + } - test_that("simple ini piping, fixed correlated model", { - testEst(f, "tka", -Inf, 0.45, Inf, FALSE) - testEst(f %>% ini(tka=0.5), "tka", -Inf, 0.5, Inf, FALSE) - testEst(f %>% ini(tka=fix), "tka", -Inf, 0.45, Inf, TRUE) + f <- rxode2(one.compartment) - testEst(f %>% ini(tka=c(0, 0.5)), "tka", 0, 0.5, Inf, FALSE) - testEst(f %>% ini(tka=c(0, 0.5, 1)), "tka", 0, 0.5, 1, FALSE) + test_that("simple ini piping, fixed correlated model", { + testEst(f, "tka", -Inf, 0.45, Inf, FALSE) + testEst(f %>% ini(tka=0.5), "tka", -Inf, 0.5, Inf, FALSE) + testEst(f %>% ini(tka=fix), "tka", -Inf, 0.45, Inf, TRUE) - expect_error(f %>% ini(tka=c(0, 0.5, 1, 4)), "tka") + testEst(f %>% ini(tka=c(0, 0.5)), "tka", 0, 0.5, Inf, FALSE) + testEst(f %>% ini(tka=c(0, 0.5, 1)), "tka", 0, 0.5, 1, FALSE) - expect_error(f %>% ini(tka=c(3,2,1)), "tka") + expect_error(f %>% ini(tka=c(0, 0.5, 1, 4)), "tka") - suppressMessages( - fFix <- f %>% ini(tka=fix) - ) - testEst(fFix, "tka", -Inf, 0.45, Inf, TRUE) - testEst(fFix %>% ini(tka=unfix), "tka", -Inf, 0.45, Inf, FALSE) - testEst(fFix %>% ini(tka=unfix(0.5)), "tka", -Inf, 0.5, Inf, FALSE) + expect_error(f %>% ini(tka=c(3,2,1)), "tka") - # should warn? Modify fixed value - testEst(f %>% ini(eta.v ~ 0.2), "eta.v", -Inf, 0.2, Inf, TRUE) + suppressMessages( + fFix <- f %>% ini(tka=fix) + ) + testEst(fFix, "tka", -Inf, 0.45, Inf, TRUE) + testEst(fFix %>% ini(tka=unfix), "tka", -Inf, 0.45, Inf, FALSE) + testEst(fFix %>% ini(tka=unfix(0.5)), "tka", -Inf, 0.5, Inf, FALSE) + + # should warn? Modify fixed value + testEst(f %>% ini(eta.v ~ 0.2), "eta.v", -Inf, 0.2, Inf, TRUE) + + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02, Inf, TRUE) + + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, TRUE) + testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02*(sqrt(0.3)*sqrt(0.1)), Inf, TRUE) + + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, TRUE), + regexp="fix.*eta.cl"), regexp="fix.*eta.v" + ) + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, TRUE), + regexp="fix.*eta.cl"), regexp="fix.*eta.v" + ) + expect_warning(expect_warning( + testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, TRUE), + regexp="fix.*eta.cl"), regexp="fix.*eta.v" + ) + + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, FALSE) + testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, FALSE) + }) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02, Inf, TRUE) + # %>% ini(tka=0.5) + # %>% ini(tka=fix) + # %>% ini(tka=unfix) + # %>% ini(eta.v~0.2) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.cl", -Inf, 0.3, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "eta.v", -Inf, 0.1, Inf, TRUE) - testEst(f %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)), "(eta.cl,eta.v)", -Inf, 0.02*(sqrt(0.3)*sqrt(0.1)), Inf, TRUE) + # Try with |> + # %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)) + # %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)) + # %>% ini(eta.v+eta.cl~fix(cor(sd(0.3,0.02,0.1)))) + # %>% ini(eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1)))) - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, TRUE), - regexp="fix.*eta.cl"), regexp="fix.*eta.v" - ) - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, TRUE), - regexp="fix.*eta.cl"), regexp="fix.*eta.v" - ) - expect_warning(expect_warning( - testEst(f %>% ini(eta.cl+eta.v~fix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, TRUE), - regexp="fix.*eta.cl"), regexp="fix.*eta.v" - ) + one.compartment <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) + }) + } - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.cl", -Inf, 0.3 * 0.3, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "eta.v", -Inf, 0.1 * 0.1, Inf, FALSE) - testEst(f %>% ini(eta.cl+eta.v~unfix(cor(sd(0.3,0.02,0.1)))), "(eta.cl,eta.v)", -Inf, 0.1 * 0.3 * 0.02, Inf, FALSE) - }) + f <- rxode2(one.compartment) - # %>% ini(tka=0.5) - # %>% ini(tka=fix) - # %>% ini(tka=unfix) - # %>% ini(eta.v~0.2) - - # Try with |> - # %>% ini(eta.cl+eta.v~c(0.3, 0.02, 0.1)) - # %>% ini(eta.cl+eta.v~cor(0.3, 0.02, 0.1)) - # %>% ini(eta.v+eta.cl~fix(cor(sd(0.3,0.02,0.1)))) - # %>% ini(eta.v+eta.cl~unfix(cor(sd(0.3,0.02,0.1)))) - - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) + testUi <- function(ui, has = NULL, exclude = NULL, values = NULL) { + uiForce <- suppressMessages(force(ui)) + if (!is.null(has)) { + expect_true(all(has %in% paste(uiForce$ini$name))) + } + if (!is.null(values) && !is.null(names(values))) { + .vals <- setNames(uiForce$ini$est, paste(uiForce$ini$name)) + .vals <- .vals[names(values)] + expect_equal(values, .vals) + } + if (!is.null(exclude)) { + expect_false(any(exclude %in% paste(uiForce$ini$name))) + } + ## General UI properties + expect_true(all(!is.na(uiForce$ini$fix))) + expect_true(all(!is.na(uiForce$ini$lower))) + expect_true(all(!is.na(uiForce$ini$upper))) + } + + test_that("update: Test Base model", { + testUi(f, c("tka", "tcl", "tv", "eta.ka", "eta.cl", "eta.v", "add.err"), + "matt", c(tka = 0.45, tcl = 1, tv = 3.45, eta.ka = 0.6, eta.cl = 0.3, eta.v = 0.1, add.err = 0.7)) }) - } - f <- rxode2(one.compartment) + test_that("UI updates work correctly", { + # context("update: Multiple component change with c()") + testUi( + f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), c(tcl = 3, tv = 4)), + c("tka", "tcl", "tv", "eta.v", "add.err"), + c("eta.ka", "eta.cl"), + c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) + ) - testUi <- function(ui, has = NULL, exclude = NULL, values = NULL) { - uiForce <- suppressMessages(force(ui)) - if (!is.null(has)) { - expect_true(all(has %in% paste(uiForce$ini$name))) - } - if (!is.null(values) && !is.null(names(values))) { - .vals <- setNames(uiForce$ini$est, paste(uiForce$ini$name)) - .vals <- .vals[names(values)] - expect_equal(values, .vals) - } - if (!is.null(exclude)) { - expect_false(any(exclude %in% paste(uiForce$ini$name))) - } - ## General UI properties - expect_true(all(!is.na(uiForce$ini$fix))) - expect_true(all(!is.na(uiForce$ini$lower))) - expect_true(all(!is.na(uiForce$ini$upper))) - } + # context("update: Multiple component change with list()") + testUi( + f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), list(tcl = 3, tv = 4)), + c("tka", "tcl", "tv", "eta.v", "add.err"), + c("eta.ka", "eta.cl"), + c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) + ) - test_that("update: Test Base model", { - testUi(f, c("tka", "tcl", "tv", "eta.ka", "eta.cl", "eta.v", "add.err"), - "matt", c(tka = 0.45, tcl = 1, tv = 3.45, eta.ka = 0.6, eta.cl = 0.3, eta.v = 0.1, add.err = 0.7)) - }) + # context("update: Multiple component change with assigned .tmp=list()") + .tmp <- list(tcl = 3, tv = 4) + testUi( + f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), .tmp), + c("tka", "tcl", "tv", "eta.v", "add.err"), + c("eta.ka", "eta.cl"), + c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) + ) - test_that("UI updates work correctly", { - # context("update: Multiple component change with c()") - testUi( - f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), c(tcl = 3, tv = 4)), - c("tka", "tcl", "tv", "eta.v", "add.err"), - c("eta.ka", "eta.cl"), - c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) - ) + # context("update: Multiple component change with assigned .tmp=c()") + .tmp <- c(tcl = 3, tv = 4) + testUi( + f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), .tmp), + c("tka", "tcl", "tv", "eta.v", "add.err"), + c("eta.ka", "eta.cl"), + c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) + ) - # context("update: Multiple component change with list()") - testUi( - f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), list(tcl = 3, tv = 4)), - c("tka", "tcl", "tv", "eta.v", "add.err"), - c("eta.ka", "eta.cl"), - c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) - ) + # context("update: Multiple component change with assigned .tmp={}") + .tmp <- quote({ + ka <- exp(tka) + }) + testUi( + f %>% update(tka = 4, cl = exp(tcl), .tmp, c(tcl = 3, tv = 4)), + c("tka", "tcl", "tv", "eta.v", "add.err"), + c("eta.ka", "eta.cl"), + c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) + ) - # context("update: Multiple component change with assigned .tmp=list()") - .tmp <- list(tcl = 3, tv = 4) - testUi( - f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), .tmp), - c("tka", "tcl", "tv", "eta.v", "add.err"), - c("eta.ka", "eta.cl"), - c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) - ) + testUi( + f %>% update( + tka = 4, + cl = exp(tcl), + { + ka <- exp(tka) + }, + c(tcl = 3, tv = 4) + ), + c("tka", "tcl", "tv", "eta.v", "add.err"), + c("eta.ka", "eta.cl"), + c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) + ) - # context("update: Multiple component change with assigned .tmp=c()") - .tmp <- c(tcl = 3, tv = 4) - testUi( - f %>% update(tka = 4, cl = exp(tcl), ka = exp(tka), .tmp), - c("tka", "tcl", "tv", "eta.v", "add.err"), - c("eta.ka", "eta.cl"), - c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) - ) + testUi( + f %>% update(ka = exp(tka)), + c("tka", "tcl", "tv", "eta.cl", "eta.v", "add.err"), + "eta.ka", c(tka = 0.45, tcl = 1, tv = 3.45, eta.cl = 0.3, eta.v = 0.1, add.err = 0.7) + ) - # context("update: Multiple component change with assigned .tmp={}") - .tmp <- quote({ - ka <- exp(tka) + ## Now test linCmt() issue #166 + one.cmt <- function() { + ini({ + tka <- 0.45 ; label("Log Ka") + tcl <- 1 ; label("Log Cl") + tv <- 3.45 ; label("Log V") + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.err) + }) + } + + suppressMessages( + .ui <- one.cmt %>% update({ + linCmt() ~ add(add.err) + prop(prop.err) + }) + ) + expect_s3_class(.ui, "rxUi") }) - testUi( - f %>% update(tka = 4, cl = exp(tcl), .tmp, c(tcl = 3, tv = 4)), - c("tka", "tcl", "tv", "eta.v", "add.err"), - c("eta.ka", "eta.cl"), - c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) - ) - testUi( - f %>% update( - tka = 4, - cl = exp(tcl), - { - ka <- exp(tka) - }, - c(tcl = 3, tv = 4) - ), - c("tka", "tcl", "tv", "eta.v", "add.err"), - c("eta.ka", "eta.cl"), - c(tka = 4, tcl = 3, tv = 4, eta.v = 0.1, add.err = 0.7) - ) + # piping looks through parent environments + test_that("Looks through prior frames for the correct object", { + fit <- rxode2(one.compartment) + fits <- lapply(seq(-1, -0.1, 0.1), function(kainit) { + suppressMessages( + rxode2(update(fit, tka = kainit)) + ) + }) - testUi( - f %>% update(ka = exp(tka)), - c("tka", "tcl", "tv", "eta.cl", "eta.v", "add.err"), - "eta.ka", c(tka = 0.45, tcl = 1, tv = 3.45, eta.cl = 0.3, eta.v = 0.1, add.err = 0.7) - ) + expect_type(fits, "list") + expect_error(lapply(seq(-1, -0.1, 0.1), function(kainit) { + suppressMessages( + rxode2(update(fit, tka = matt)) + ) + })) + }) - ## Now test linCmt() issue #166 - one.cmt <- function() { + one.compartment <- function() { ini({ tka <- 0.45 ; label("Log Ka") tcl <- 1 ; label("Log Cl") @@ -1154,182 +1198,168 @@ rxTest({ ka <- exp(tka + eta.ka) cl <- exp(tcl + eta.cl) v <- exp(tv + eta.v) - linCmt() ~ add(add.err) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) }) } - suppressMessages( - .ui <- one.cmt %>% update({ - linCmt() ~ add(add.err) + prop(prop.err) - }) - ) - expect_s3_class(.ui, "rxUi") - }) + f <- rxode2(one.compartment) - # piping looks through parent environments - test_that("Looks through prior frames for the correct object", { - fit <- rxode2(one.compartment) - fits <- lapply(seq(-1, -0.1, 0.1), function(kainit) { - suppressMessages( - rxode2(update(fit, tka = kainit)) + test_that("piping works for correlations #1", { + testUi(f %>% ini(eta.ka + eta.cl ~ c( + 0.2, + 0.01, 0.2 + )), + has = c("tka", "tcl", "tv", "eta.ka", "eta.cl", "eta.v", "add.err", "(eta.ka,eta.cl)"), + exclude = "matt", + values = c( + tka = 0.45, tcl = 1, tv = 3.45, eta.ka = 0.2, eta.cl = 0.2, eta.v = 0.1, add.err = 0.7, + `(eta.ka,eta.cl)` = 0.01 + ) ) }) - expect_type(fits, "list") - expect_error(lapply(seq(-1, -0.1, 0.1), function(kainit) { + test_that("piping works for correlations #2", { suppressMessages( - rxode2(update(fit, tka = matt)) + expect_error( + f %>% + ini(eta.ka + eta.matt ~ c(0.2, + 0.01, 0.2) + ) + ) ) - })) - }) + }) - one.compartment <- function() { - ini({ - tka <- 0.45 ; label("Log Ka") - tcl <- 1 ; label("Log Cl") - tv <- 3.45 ; label("Log V") - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 + test_that("piping works for correlations #3", { + testUi( + f %>% update(eta.ka + eta.cl ~ c( + 0.2, + 0.01, 0.2 + )), + c("tka", "tcl", "tv", "eta.ka", "eta.cl", "eta.v", "add.err", "(eta.ka,eta.cl)"), + "matt", c( + tka = 0.45, tcl = 1, tv = 3.45, eta.ka = 0.2, eta.cl = 0.2, eta.v = 0.1, add.err = 0.7, + `(eta.ka,eta.cl)` = 0.01 + ) + ) }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) + + test_that("piping works for correlations #4", { + suppressMessages( + expect_error( + f %>% + update(eta.ka + eta.matt ~ c(0.2, + 0.01, 0.2) + ) + ) + ) }) - } - f <- rxode2(one.compartment) - - test_that("piping works for correlations #1", { - testUi(f %>% ini(eta.ka + eta.cl ~ c( - 0.2, - 0.01, 0.2 - )), - has = c("tka", "tcl", "tv", "eta.ka", "eta.cl", "eta.v", "add.err", "(eta.ka,eta.cl)"), - exclude = "matt", - values = c( - tka = 0.45, tcl = 1, tv = 3.45, eta.ka = 0.2, eta.cl = 0.2, eta.v = 0.1, add.err = 0.7, - `(eta.ka,eta.cl)` = 0.01 - ) - ) - }) + test_that("expected piping errors", { + f <- function() { + ini({ + ke <- 0.5 + eta.ke ~ 0.04 + prop.sd <- sqrt(0.1) + }) + model({ + ke <- ke * exp(eta.ke) + ipre <- 10 * exp(-ke * t) + ipre ~ prop(prop.sd) + }) + } - test_that("piping works for correlations #2", { - suppressMessages( - expect_error( - f %>% - ini(eta.ka + eta.matt ~ c(0.2, - 0.01, 0.2) - ) - ) - ) - }) + f <- rxode2::rxode2(f) - test_that("piping works for correlations #3", { - testUi( - f %>% update(eta.ka + eta.cl ~ c( - 0.2, - 0.01, 0.2 - )), - c("tka", "tcl", "tv", "eta.ka", "eta.cl", "eta.v", "add.err", "(eta.ka,eta.cl)"), - "matt", c( - tka = 0.45, tcl = 1, tv = 3.45, eta.ka = 0.2, eta.cl = 0.2, eta.v = 0.1, add.err = 0.7, - `(eta.ka,eta.cl)` = 0.01 + suppressMessages( + expect_error(f %>% model(ipre ~ add(add.sd)) %>% ini(add.sd=sqrt(0.1)), NA) ) - ) - }) + }) - test_that("piping works for correlations #4", { - suppressMessages( - expect_error( - f %>% - update(eta.ka + eta.matt ~ c(0.2, - 0.01, 0.2) - ) - ) - ) - }) + test_that("new ipre", { + f <- function() { + ini({ + tke <- 0.5 + eta.ke ~ 0.04 + prop.sd <- sqrt(0.1) + }) + model({ + ke <- tke * exp(eta.ke) + ipre <- 10 * exp(-ke * t) + f2 <- ipre / (ipre + 5) + ipre ~ prop(prop.sd) + }) + } - test_that("expected piping errors", { - f <- function() { - ini({ - ke <- 0.5 - eta.ke ~ 0.04 - prop.sd <- sqrt(0.1) - }) - model({ - ke <- ke * exp(eta.ke) - ipre <- 10 * exp(-ke * t) - ipre ~ prop(prop.sd) - }) - } + f <- rxode2(f) - f <- rxode2::rxode2(f) + trans <- function(f) { + suppressMessages( + f %>% model(ipre ~ propF(prop.sd, f2)) %>% ini(prop.sd=sqrt(0.1)) + ) + } - suppressMessages( - expect_error(f %>% model(ipre ~ add(add.sd)) %>% ini(add.sd=sqrt(0.1)), NA) - ) - }) + f2 <- trans(f) - test_that("new ipre", { - f <- function() { - ini({ - tke <- 0.5 - eta.ke ~ 0.04 - prop.sd <- sqrt(0.1) - }) - model({ - ke <- tke * exp(eta.ke) - ipre <- 10 * exp(-ke * t) - f2 <- ipre / (ipre + 5) - ipre ~ prop(prop.sd) - }) - } + expect_true(!any(f2$iniDf$name %in% c("f2"))) + }) - f <- rxode2(f) + test_that("piping looks in the right environment for variables with fix()", { + f <- function() { + ini({ + tke <- 0.5 + eta.ke ~ 0.04 + prop.sd <- sqrt(0.1) + }) + model({ + ke <- tke * exp(eta.ke) + ipre <- 10 * exp(-ke * t) + f2 <- ipre / (ipre + 5) + ipre ~ prop(prop.sd) + }) + } - trans <- function(f) { + intke <- 5 suppressMessages( - f %>% model(ipre ~ propF(prop.sd, f2)) %>% ini(prop.sd=sqrt(0.1)) + tmp <- f %>% ini(tke=fix(intke)) ) - } - - f2 <- trans(f) - expect_true(!any(f2$iniDf$name %in% c("f2"))) - }) + expect_true(tmp$iniDf[tmp$iniDf$name == "tke","fix"]) + expect_equal(tmp$iniDf[tmp$iniDf$name == "tke","est"], 5) + rm(list="intke") + + f2 <- function() { + f <- function() { + ini({ + tke <- 0.5 + eta.ke ~ 0.04 + prop.sd <- sqrt(0.1) + }) + model({ + ke <- tke * exp(eta.ke) + ipre <- 10 * exp(-ke * t) + f2 <- ipre / (ipre + 5) + ipre ~ prop(prop.sd) + }) + } + + intke <- 5 + f %>% ini(tke=fix(intke)) + } - test_that("piping looks in the right environment for variables with fix()", { - f <- function() { - ini({ - tke <- 0.5 - eta.ke ~ 0.04 - prop.sd <- sqrt(0.1) - }) - model({ - ke <- tke * exp(eta.ke) - ipre <- 10 * exp(-ke * t) - f2 <- ipre / (ipre + 5) - ipre ~ prop(prop.sd) - }) - } + suppressMessages( + tmp <- f2() + ) - intke <- 5 - suppressMessages( - tmp <- f %>% ini(tke=fix(intke)) - ) + expect_true(tmp$iniDf[tmp$iniDf$name == "tke","fix"]) + expect_equal(tmp$iniDf[tmp$iniDf$name == "tke","est"], 5) - expect_true(tmp$iniDf[tmp$iniDf$name == "tke","fix"]) - expect_equal(tmp$iniDf[tmp$iniDf$name == "tke","est"], 5) - rm(list="intke") + expect_false(any(ls() == "intke")) + }) - f2 <- function() { + test_that("invalid model pipe (more arguments than expected) throws an error", { f <- function() { ini({ tke <- 0.5 @@ -1340,349 +1370,391 @@ rxTest({ ke <- tke * exp(eta.ke) ipre <- 10 * exp(-ke * t) f2 <- ipre / (ipre + 5) + f3 <- f2 * 3 + lipre <- log(ipre) ipre ~ prop(prop.sd) }) } - intke <- 5 - f %>% ini(tke=fix(intke)) - } - - suppressMessages( - tmp <- f2() - ) + expect_error(f %>% model(ipre~prop(f2,f3,c))) + }) - expect_true(tmp$iniDf[tmp$iniDf$name == "tke","fix"]) - expect_equal(tmp$iniDf[tmp$iniDf$name == "tke","est"], 5) + test_that("Add an eta to a model that does not have an eta will work", { + ocmt <- function() { + ini({ + tka <- exp(0.45) + tcl <- exp(1) + tv <- exp(3.45) + add.sd <- 0.7 + }) + model({ + ka <- tka + cl <- tcl + v <- tv + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + cp ~ add(add.sd) + }) + } - expect_false(any(ls() == "intke")) - }) + suppressMessages( + expect_error( + ocmt %>% + model(ka <- exp(tka + eta.ka)), + NA + ) + ) + }) - test_that("invalid model pipe (more arguments than expected) throws an error", { - f <- function() { - ini({ - tke <- 0.5 - eta.ke ~ 0.04 - prop.sd <- sqrt(0.1) - }) - model({ - ke <- tke * exp(eta.ke) - ipre <- 10 * exp(-ke * t) - f2 <- ipre / (ipre + 5) - f3 <- f2 * 3 - lipre <- log(ipre) - ipre ~ prop(prop.sd) - }) - } + test_that("Add covariate to model works", { + ocmt <- function() { + ini({ + tka <- exp(0.45) + tcl <- exp(1) + tv <- exp(3.45) + add.sd <- 0.7 + }) + model({ + ka <- tka + cl <- tcl + v <- tv + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + cp ~ add(add.sd) + }) + } - expect_error(f %>% model(ipre~prop(f2,f3,c))) - }) - test_that("Add an eta to a model that does not have an eta will work", { - ocmt <- function() { - ini({ - tka <- exp(0.45) - tcl <- exp(1) - tv <- exp(3.45) - add.sd <- 0.7 - }) - model({ - ka <- tka - cl <- tcl - v <- tv - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - cp ~ add(add.sd) - }) - } + suppressMessages( + expect_error( + ocmt %>% + model(ka <- exp(tka + covKa * wt + eta.ka)), + NA + ) + ) - suppressMessages( - expect_error( - ocmt %>% - model(ka <- exp(tka + eta.ka)), - NA + suppressMessages( + tmp <- + ocmt %>% + model(ka <- exp(tka + covKaWt * wt + eta.ka)) ) - ) - }) + expect_equal(tmp$allCovs, "wt") - test_that("Add covariate to model works", { - ocmt <- function() { - ini({ - tka <- exp(0.45) - tcl <- exp(1) - tv <- exp(3.45) - add.sd <- 0.7 - }) - model({ - ka <- tka - cl <- tcl - v <- tv - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - cp ~ add(add.sd) - }) - } + expect_true("covKaWt" %in% tmp$iniDf$name) + expect_true("tka" %in% tmp$iniDf$name) + expect_true("eta.ka" %in% tmp$iniDf$name) + + suppressMessages( + tmp <- + ocmt %>% + model(ka <- exp(covKaWt * wt + eta.ka)) + ) + expect_equal(tmp$allCovs, "wt") + expect_true("covKaWt" %in% tmp$iniDf$name) + expect_false("tka" %in% tmp$iniDf$name) + expect_true("eta.ka" %in% tmp$iniDf$name) - suppressMessages( - expect_error( - ocmt %>% - model(ka <- exp(tka + covKa * wt + eta.ka)), - NA + suppressMessages( + tmp <- + tmp %>% + model(ka <- exp(tka + covKaWt * wt + eta.ka)) ) - ) + expect_equal(tmp$allCovs, "wt") + expect_true("covKaWt" %in% tmp$iniDf$name) + expect_true("tka" %in% tmp$iniDf$name) + expect_true("eta.ka" %in% tmp$iniDf$name) + }) - suppressMessages( - tmp <- - ocmt %>% - model(ka <- exp(tka + covKaWt * wt + eta.ka)) - ) - expect_equal(tmp$allCovs, "wt") + test_that("Appending or pre-pending items to a model works", { + ocmt <- function() { + ini({ + tka <- exp(0.45) + tcl <- exp(1) + tv <- exp(3.45) + add.sd <- 0.7 + }) + model({ + ka <- tka + cl <- tcl + v <- tv + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + cp ~ add(add.sd) + }) + } - expect_true("covKaWt" %in% tmp$iniDf$name) - expect_true("tka" %in% tmp$iniDf$name) - expect_true("eta.ka" %in% tmp$iniDf$name) + f <- rxode2(ocmt) + f2 <- f %>% model(cp1 <- cp, append=TRUE) - suppressMessages( - tmp <- - ocmt %>% - model(ka <- exp(covKaWt * wt + eta.ka)) - ) + expect_true("cp1" %in% f2$mv0$lhs) + expect_equal(f2$lstExpr[[length(f2$lstExpr)]], quote(cp1 <- cp)) - expect_equal(tmp$allCovs, "wt") - expect_true("covKaWt" %in% tmp$iniDf$name) - expect_false("tka" %in% tmp$iniDf$name) - expect_true("eta.ka" %in% tmp$iniDf$name) + f <- rxode2(ocmt) + f2 <- f %>% model(cp1 <- cp, append=Inf) - suppressMessages( - tmp <- - tmp %>% - model(ka <- exp(tka + covKaWt * wt + eta.ka)) - ) - expect_equal(tmp$allCovs, "wt") - expect_true("covKaWt" %in% tmp$iniDf$name) - expect_true("tka" %in% tmp$iniDf$name) - expect_true("eta.ka" %in% tmp$iniDf$name) - }) + expect_true("cp1" %in% f2$mv0$lhs) + expect_equal(f2$lstExpr[[length(f2$lstExpr)]], quote(cp1 <- cp)) - test_that("Appending or pre-pending items to a model works", { - ocmt <- function() { - ini({ - tka <- exp(0.45) - tcl <- exp(1) - tv <- exp(3.45) - add.sd <- 0.7 - }) - model({ - ka <- tka - cl <- tcl - v <- tv - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - cp ~ add(add.sd) - }) - } + f <- rxode2(ocmt) + f2 <- f %>% model(cp1 <- cp, append=100) + + expect_true("cp1" %in% f2$mv0$lhs) + expect_equal(f2$lstExpr[[length(f2$lstExpr)]], quote(cp1 <- cp)) - f <- rxode2(ocmt) - f2 <- f %>% model(cp1 <- cp, append=TRUE) + f2 <- f %>% model(f2 <- 3 * 2, append=NA) + expect_true("f2" %in% f2$mv0$lhs) + expect_equal(f2$lstExpr[[1]], quote(f2 <- 3 * 2)) + }) - expect_true("cp1" %in% f2$mv0$lhs) - expect_equal(f2$lstExpr[[length(f2$lstExpr)]], quote(cp1 <- cp)) + test_that("ini promotion works", { + ocmt <- function() { + ini({ + tka <- 0.45 + tcl <- 1 + add.sd <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + cp ~ add(add.sd) + }) + } + + f <- rxode2(ocmt) - f <- rxode2(ocmt) - f2 <- f %>% model(cp1 <- cp, append=Inf) + expect_equal(f$allCovs, c("eta.ka", "eta.cl", "tv", "eta.v")) + expect_equal(f$theta, c(tka=0.45, tcl=1, add.sd=0.7)) + expect_equal(f$omega, NULL) - expect_true("cp1" %in% f2$mv0$lhs) - expect_equal(f2$lstExpr[[length(f2$lstExpr)]], quote(cp1 <- cp)) + # now promote tv + suppressMessages( + f2 <- f %>% ini(tv=0.5) + ) + expect_equal(f2$allCovs, c("eta.ka", "eta.cl", "eta.v")) + expect_equal(f2$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) + expect_equal(f2$omega, NULL) - f <- rxode2(ocmt) - f2 <- f %>% model(cp1 <- cp, append=100) + # now promote eta.ka + suppressMessages( + f3 <- f2 %>% ini(eta.ka ~ 0.01) + ) - expect_true("cp1" %in% f2$mv0$lhs) - expect_equal(f2$lstExpr[[length(f2$lstExpr)]], quote(cp1 <- cp)) + expect_equal(f3$allCovs, c("eta.cl", "eta.v")) + expect_equal(f3$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) + expect_equal(f3$omega, matrix(0.01, dimnames=list("eta.ka", "eta.ka"))) - f2 <- f %>% model(f2 <- 3 * 2, append=NA) - expect_true("f2" %in% f2$mv0$lhs) - expect_equal(f2$lstExpr[[1]], quote(f2 <- 3 * 2)) - }) + # now promote a correlation between eta.cl and eta.v + suppressMessages( + f4 <- f2 %>% ini(eta.cl + eta.v ~ c(1, + 0.01, 1)) + ) + expect_equal(f4$allCovs, "eta.ka") + expect_equal(f4$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) - test_that("ini promotion works", { - ocmt <- function() { - ini({ - tka <- 0.45 - tcl <- 1 - add.sd <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - cp ~ add(add.sd) - }) - } + expect_equal(f4$omega, lotri(eta.cl + eta.v ~ c(1, + 0.01, 1))) - f <- rxode2(ocmt) + # Now promote independent eta block + suppressMessages( + f5 <- f3 %>% ini(eta.cl + eta.v ~ c(1, + 0.01, 1)) + ) + expect_length(f5$allCovs, 0) + expect_equal(f5$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) + expect_equal(f5$omega, lotri(eta.ka ~ 0.01, + eta.cl + eta.v ~ c(1, + 0.01, 1))) - expect_equal(f$allCovs, c("eta.ka", "eta.cl", "tv", "eta.v")) - expect_equal(f$theta, c(tka=0.45, tcl=1, add.sd=0.7)) - expect_equal(f$omega, NULL) + # Now promote eta block that includes prior eta information + suppressMessages( + f6 <- f3 %>% ini(eta.ka + eta.cl + eta.v ~ c(1, + 0.01, 1, + -0.01, 0.01, 1)) + ) + expect_length(f6$allCovs, 0) + expect_equal(f6$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) + expect_equal(f6$omega, lotri(eta.ka + eta.cl + eta.v ~ c(1, + 0.01, 1, + -0.01, 0.01, 1))) + }) - # now promote tv - suppressMessages( - f2 <- f %>% ini(tv=0.5) - ) - expect_equal(f2$allCovs, c("eta.ka", "eta.cl", "eta.v")) - expect_equal(f2$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) - expect_equal(f2$omega, NULL) + test_that("Ignoring auto-selected parameter types work", { + ocmt <- function() { + ini({ + tka <- exp(0.45) + tcl <- exp(1) + eta.v ~ 0.01 + add.sd <- 0.7 + }) + model({ + ka <- tka + cl <- tcl + v <- eta.v + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + cp ~ add(add.sd) + }) + } - # now promote eta.ka - suppressMessages( - f3 <- f2 %>% ini(eta.ka ~ 0.01) - ) + suppressWarnings( + f <- rxode2(ocmt) + ) - expect_equal(f3$allCovs, c("eta.cl", "eta.v")) - expect_equal(f3$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) - expect_equal(f3$omega, matrix(0.01, dimnames=list("eta.ka", "eta.ka"))) + expect_equal(f$allCovs, character(0)) + expect_equal(f$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) + expect_equal(f$omega, matrix(0.01, dimnames=list("eta.v", "eta.v"))) + + suppressMessages(suppressWarnings( + f2 <- f %>% model(ka <- tka * exp(eta.ka), auto=FALSE) + )) + + expect_equal(f2$allCovs, "eta.ka") + expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) + expect_equal(f2$omega, matrix(0.01, dimnames=list("eta.v", "eta.v"))) + + suppressMessages(suppressWarnings( + f2 <- + f %>% + model(ka <- tka * exp(eta.ka), auto=FALSE) %>% + ini(eta.ka ~ 0.02) + )) + expect_equal(f2$allCovs, character(0)) + expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) + expect_equal(f2$omega, lotri(eta.v ~ 0.01, + eta.ka ~ 0.02)) + + suppressMessages(suppressWarnings( + f2 <- f %>% model(v <- tv + eta.v, auto=FALSE) + )) + expect_equal(f2$allCovs, "tv") + expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) + expect_equal(f2$omega, lotri(eta.v ~ 0.01)) + + suppressMessages(suppressWarnings( + f2 <- f %>% model(v <- tv + eta.v, auto=FALSE) %>% + ini(tv=0.2) + )) + expect_equal(f2$allCovs, character(0)) + expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7, tv=0.2)) + expect_equal(f2$omega, lotri(eta.v ~ 0.01)) + }) - # now promote a correlation between eta.cl and eta.v - suppressMessages( - f4 <- f2 %>% ini(eta.cl + eta.v ~ c(1, - 0.01, 1)) - ) - expect_equal(f4$allCovs, "eta.ka") - expect_equal(f4$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) + test_that("Ignoring auto-selected parameter types work", { + ocmt <- function() { + ini({ + tka <- exp(0.45) + tcl <- exp(1) + eta.v ~ 0.01 + add.sd <- 0.7 + tprop <- 0.5 + prop.eta ~ 0.01 + }) + model({ + ka <- tka + cl <- tcl + v <- eta.v + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v + prop.sd <- exp(tprop + prop.eta) + cp ~ add(add.sd) + }) + } - expect_equal(f4$omega, lotri(eta.cl + eta.v ~ c(1, - 0.01, 1))) + suppressWarnings( + f1 <- ocmt() + ) + suppressWarnings( + f2 <- ocmt %>% model(cp ~ add(add.sd) + prop(prop.sd)) + ) + expect_equal(f2$theta, f1$theta) + expect_equal(f2$omega, f1$omega) + }) - # Now promote independent eta block - suppressMessages( - f5 <- f3 %>% ini(eta.cl + eta.v ~ c(1, - 0.01, 1)) - ) - expect_length(f5$allCovs, 0) - expect_equal(f5$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) - expect_equal(f5$omega, lotri(eta.ka ~ 0.01, - eta.cl + eta.v ~ c(1, - 0.01, 1))) + test_that("Pre-declaring list of covariates works", { + rxSetCovariateNamesForPiping(c("WT","HT", "TC")) - # Now promote eta block that includes prior eta information - suppressMessages( - f6 <- f3 %>% ini(eta.ka + eta.cl + eta.v ~ c(1, - 0.01, 1, - -0.01, 0.01, 1)) - ) - expect_length(f6$allCovs, 0) - expect_equal(f6$theta, c(tka=0.45, tcl=1, add.sd=0.7, tv=0.5)) - expect_equal(f6$omega, lotri(eta.ka + eta.cl + eta.v ~ c(1, - 0.01, 1, - -0.01, 0.01, 1))) - }) + # Note this is case sensitive + one.compartment <- function() { + ini({ + tka <- 0.45 + tcl <- 1 + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d/dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) + }) + } - test_that("Ignoring auto-selected parameter types work", { - ocmt <- function() { - ini({ - tka <- exp(0.45) - tcl <- exp(1) - eta.v ~ 0.01 - add.sd <- 0.7 - }) - model({ - ka <- tka - cl <- tcl - v <- eta.v - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - cp ~ add(add.sd) - }) - } + # now TC is detected as a covariate instead of a population parameter + suppressMessages( + mod <- + one.compartment %>% + model({ka <- exp(tka + eta.ka + TC * cov_C)}) + ) + expect_true("cov_C" %in% mod$iniDf$name) + expect_false("TC" %in% mod$iniDf$name) - suppressWarnings( - f <- rxode2(ocmt) - ) + rxSetCovariateNamesForPiping() - expect_equal(f$allCovs, character(0)) - expect_equal(f$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) - expect_equal(f$omega, matrix(0.01, dimnames=list("eta.v", "eta.v"))) - - suppressMessages(suppressWarnings( - f2 <- f %>% model(ka <- tka * exp(eta.ka), auto=FALSE) - )) - - expect_equal(f2$allCovs, "eta.ka") - expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) - expect_equal(f2$omega, matrix(0.01, dimnames=list("eta.v", "eta.v"))) - - suppressMessages(suppressWarnings( - f2 <- - f %>% - model(ka <- tka * exp(eta.ka), auto=FALSE) %>% - ini(eta.ka ~ 0.02) - )) - expect_equal(f2$allCovs, character(0)) - expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) - expect_equal(f2$omega, lotri(eta.v ~ 0.01, - eta.ka ~ 0.02)) - - suppressMessages(suppressWarnings( - f2 <- f %>% model(v <- tv + eta.v, auto=FALSE) - )) - expect_equal(f2$allCovs, "tv") - expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7)) - expect_equal(f2$omega, lotri(eta.v ~ 0.01)) - - suppressMessages(suppressWarnings( - f2 <- f %>% model(v <- tv + eta.v, auto=FALSE) %>% - ini(tv=0.2) - )) - expect_equal(f2$allCovs, character(0)) - expect_equal(f2$theta, c(tka=exp(0.45), tcl=exp(1), add.sd=0.7, tv=0.2)) - expect_equal(f2$omega, lotri(eta.v ~ 0.01)) + suppressMessages( + mod <- + one.compartment %>% + model({ka <- exp(tka + eta.ka + TC * cov_C)}) + ) + expect_true("cov_C" %in% mod$iniDf$name) + expect_true("TC" %in% mod$iniDf$name) + }) }) - test_that("Ignoring auto-selected parameter types work", { - ocmt <- function() { - ini({ - tka <- exp(0.45) - tcl <- exp(1) - eta.v ~ 0.01 - add.sd <- 0.7 - tprop <- 0.5 - prop.eta ~ 0.01 - }) - model({ - ka <- tka - cl <- tcl - v <- eta.v - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - prop.sd <- exp(tprop + prop.eta) - cp ~ add(add.sd) - }) - } + test_that("eff(0) piping should work", { + mod1 <- rxode2({ + C2 <- centr/V2 + C3 <- peri/V3 + d/dt(depot) <- -KA*depot + d/dt(centr) <- KA*depot - CL*C2 - Q*C2 + Q*C3 + d/dt(peri) <- Q*C2 - Q*C3 + d/dt(eff) <- Kin - Kout*(1-C2/(EC50+C2))*eff + }) - suppressWarnings( - f1 <- ocmt() - ) - suppressWarnings( - f2 <- ocmt %>% model(cp ~ add(add.sd) + prop(prop.sd)) + suppressMessages( + expect_error( + mod1 %>% + model(KA<-exp(tka+eta.ka), append=NA) %>% # Prepend a line by append=NA + ini(tka=log(2.94E-01), + eta.ka=0.2, + CL=1.86E+01, V2=4.02E+01, # central + Q=1.05E+01, V3=2.97E+02, # peripheral + Kin=1, Kout=1, EC50=200) %>% + model(eff(0) <- 1), + NA + ) ) - expect_equal(f2$theta, f1$theta) - expect_equal(f2$omega, f1$omega) }) - test_that("Pre-declaring list of covariates works", { - rxSetCovariateNamesForPiping(c("WT","HT", "TC")) - # Note this is case sensitive + test_that("auto with studid==", { + one.compartment <- function() { ini({ tka <- 0.45 @@ -1691,526 +1763,456 @@ rxTest({ eta.ka ~ 0.6 eta.cl ~ 0.3 eta.v ~ 0.1 - add.err <- 0.7 + add.sd <- 0.7 }) model({ ka <- exp(tka + eta.ka) cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d/dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) + v <- exp(tv+eta.v) + cp <- linCmt() + cp ~ add(add.sd) }) } - # now TC is detected as a covariate instead of a population parameter - suppressMessages( - mod <- - one.compartment %>% - model({ka <- exp(tka + eta.ka + TC * cov_C)}) - ) - expect_true("cov_C" %in% mod$iniDf$name) - expect_false("TC" %in% mod$iniDf$name) - - rxSetCovariateNamesForPiping() - suppressMessages( - mod <- - one.compartment %>% - model({ka <- exp(tka + eta.ka + TC * cov_C)}) - ) - expect_true("cov_C" %in% mod$iniDf$name) - expect_true("TC" %in% mod$iniDf$name) - }) -}) + i <- rxode2(one.compartment) -test_that("eff(0) piping should work", { - mod1 <- rxode2({ - C2 <- centr/V2 - C3 <- peri/V3 - d/dt(depot) <- -KA*depot - d/dt(centr) <- KA*depot - CL*C2 - Q*C2 + Q*C3 - d/dt(peri) <- Q*C2 - Q*C3 - d/dt(eff) <- Kin - Kout*(1-C2/(EC50+C2))*eff - }) + j <- i %>% + model({ + f(central) <- 1 + f_study1*(STUDYID==1) + }, + append=NA, + auto=FALSE) - suppressMessages( - expect_error( - mod1 %>% - model(KA<-exp(tka+eta.ka), append=NA) %>% # Prepend a line by append=NA - ini(tka=log(2.94E-01), - eta.ka=0.2, - CL=1.86E+01, V2=4.02E+01, # central - Q=1.05E+01, V3=2.97E+02, # peripheral - Kin=1, Kout=1, EC50=200) %>% - model(eff(0) <- 1), - NA - ) - ) -}) + expect_false(any(j$iniDf$name == "f_study1")) + expect_false(any(j$iniDf$name == "STUDYID")) + }) -test_that("auto with studid==", { + test_that("piping with append=lhs", { - one.compartment <- function() { - ini({ - tka <- 0.45 - tcl <- 1 - tv <- 3.45 - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.sd <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv+eta.v) - cp <- linCmt() - cp ~ add(add.sd) + ocmt_rx0 <- rxode2( { + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl / v * center + cp = center / v }) - } + m1 <- ocmt_rx0 %>% model( cl <- tvcl*2, append = NA) - i <- rxode2(one.compartment) + expect_true(identical(m1$lstExpr[[1]], quote(cl <- tvcl * 2))) - j <- i %>% - model({ - f(central) <- 1 + f_study1*(STUDYID==1) - }, - append=NA, - auto=FALSE) + m2 <- ocmt_rx0 %>% model( cl <- tvcl*2, append = d/dt(depot)) - expect_false(any(j$iniDf$name == "f_study1")) - expect_false(any(j$iniDf$name == "STUDYID")) + expect_true(identical(m2$lstExpr[[2]], quote(cl <- tvcl * 2))) -}) + expect_error(ocmt_rx0 %>% model( cl <- tvcl*2, append = notFound)) -test_that("piping with append=lhs", { + m3 <- ocmt_rx0 %>% model( cl <- tvcl*2, append = cp) - ocmt_rx0 <- rxode2( { - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl / v * center - cp = center / v - }) + expect_true(identical(m3$lstExpr[[4]], quote(cl <- tvcl * 2))) - m1 <- ocmt_rx0 %>% model( cl <- tvcl*2, append = NA) + test_that("piping ui functions", { - expect_true(identical(m1$lstExpr[[1]], quote(cl <- tvcl * 2))) + m1 <- function() { + ini({ + tka <- 0.463613555325211 + label("Ka") + tcl <- c(-Inf, 1.01211464338867, 4.60517018598809) + label("Log Cl") + tv <- 3.46039743010498 + label("log V") + add.sd <- c(0, 0.694761430696633) + eta.ka ~ 0.400673718508127 + eta.cl ~ 0.069154564934726 + eta.v ~ 0.0191298379535425 + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } - m2 <- ocmt_rx0 %>% model( cl <- tvcl*2, append = d/dt(depot)) + m1 <- m1() - expect_true(identical(m2$lstExpr[[2]], quote(cl <- tvcl * 2))) + m2 <- function() { + ini({ + tcl <- c(-Inf, 1.01211464338867, 4.60517018598809) + label("Log Cl") + tv <- 3.46039743010498 + label("log V") + add.sd <- c(0, 0.694761430696633) + eta.cl ~ 0.069154564934726 + eta.v ~ 0.0191298379535425 + }) + model({ + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + linCmt() ~ add(add.sd) + }) + } - expect_error(ocmt_rx0 %>% model( cl <- tvcl*2, append = notFound)) + m2 <- m2() - m3 <- ocmt_rx0 %>% model( cl <- tvcl*2, append = cp) + expect_equal(testPipeQuote(m1, iniDf=m2$iniDf), + list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), + quote(tv <- 3.46039743010498), + quote(add.sd <- c(0, 0.694761430696633)), + quote(eta.cl ~ 0.069154564934726), + quote(eta.v ~ 0.0191298379535425))) - expect_true(identical(m3$lstExpr[[4]], quote(cl <- tvcl * 2))) + expect_equal(testPipeQuote(m2, iniDf=m1$iniDf), + list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), + quote(tv <- 3.46039743010498), + quote(add.sd <- c(0, 0.694761430696633)), + quote(eta.cl ~ 0.069154564934726), + quote(eta.v ~ 0.0191298379535425))) - test_that("piping ui functions", { + m4 <- function() { + ini({ + tcl <- c(-Inf, 1.01211464338867, 4.60517018598809) + label("Log Cl") + tv <- 3.46039743010498 + label("log V") + add.sd <- c(0, 0.694761430696633) + eta..cl ~ 0.069154564934726 + eta..v ~ 0.0191298379535425 + }) + model({ + cl <- exp(tcl + eta..cl) + v <- exp(tv + eta..v) + linCmt() ~ add(add.sd) + }) + } - m1 <- function() { - ini({ - tka <- 0.463613555325211 - label("Ka") - tcl <- c(-Inf, 1.01211464338867, 4.60517018598809) - label("Log Cl") - tv <- 3.46039743010498 - label("log V") - add.sd <- c(0, 0.694761430696633) - eta.ka ~ 0.400673718508127 - eta.cl ~ 0.069154564934726 - eta.v ~ 0.0191298379535425 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - linCmt() ~ add(add.sd) - }) - } + # no etas - m1 <- m1() + m4 <- m4() - m2 <- function() { - ini({ - tcl <- c(-Inf, 1.01211464338867, 4.60517018598809) - label("Log Cl") - tv <- 3.46039743010498 - label("log V") - add.sd <- c(0, 0.694761430696633) - eta.cl ~ 0.069154564934726 - eta.v ~ 0.0191298379535425 - }) - model({ - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - linCmt() ~ add(add.sd) - }) - } + expect_equal(testPipeQuote(m4, iniDf=m1$iniDf), + list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), + quote(tv <- 3.46039743010498), + quote(add.sd <- c(0, 0.694761430696633)))) - m2 <- m2() + expect_equal(testPipeQuote(m1, iniDf=m4$iniDf), + list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), + quote(tv <- 3.46039743010498), + quote(add.sd <- c(0, 0.694761430696633)))) - expect_equal(testPipeQuote(m1, iniDf=m2$iniDf), - list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), - quote(tv <- 3.46039743010498), - quote(add.sd <- c(0, 0.694761430696633)), - quote(eta.cl ~ 0.069154564934726), - quote(eta.v ~ 0.0191298379535425))) + # no thetas - expect_equal(testPipeQuote(m2, iniDf=m1$iniDf), - list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), - quote(tv <- 3.46039743010498), - quote(add.sd <- c(0, 0.694761430696633)), - quote(eta.cl ~ 0.069154564934726), - quote(eta.v ~ 0.0191298379535425))) + m5 <- function() { + ini({ + t.cl <- c(-Inf, 1.01211464338867, 4.60517018598809) + label("Log Cl") + t.v <- 3.46039743010498 + label("log V") + add..sd <- c(0, 0.694761430696633) + eta.cl ~ 0.069154564934726 + eta.v ~ 0.0191298379535425 + }) + model({ + cl <- exp(t.cl + eta.cl) + v <- exp(t.v + eta.v) + linCmt() ~ add(add..sd) + }) + } - m4 <- function() { - ini({ - tcl <- c(-Inf, 1.01211464338867, 4.60517018598809) - label("Log Cl") - tv <- 3.46039743010498 - label("log V") - add.sd <- c(0, 0.694761430696633) - eta..cl ~ 0.069154564934726 - eta..v ~ 0.0191298379535425 - }) - model({ - cl <- exp(tcl + eta..cl) - v <- exp(tv + eta..v) - linCmt() ~ add(add.sd) - }) - } + m5 <- m5() - # no etas + expect_equal(testPipeQuote(m5, iniDf=m1$iniDf), + list(quote(eta.cl ~ 0.069154564934726), + quote(eta.v ~ 0.0191298379535425))) - m4 <- m4() + expect_equal(testPipeQuote(m1, iniDf=m5$iniDf), + list(quote(eta.cl ~ 0.069154564934726), + quote(eta.v ~ 0.0191298379535425))) - expect_equal(testPipeQuote(m4, iniDf=m1$iniDf), - list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), - quote(tv <- 3.46039743010498), - quote(add.sd <- c(0, 0.694761430696633)))) - expect_equal(testPipeQuote(m1, iniDf=m4$iniDf), - list(quote(tcl <- c(-Inf, 1.01211464338867, 4.60517018598809)), - quote(tv <- 3.46039743010498), - quote(add.sd <- c(0, 0.694761430696633)))) + m6 <- function() { + ini({ + t.cl <- c(-Inf, 1.01211464338867, 4.60517018598809) + label("Log Cl") + t.v <- 3.46039743010498 + label("log V") + add..sd <- c(0, 0.694761430696633) + eta..cl ~ 0.069154564934726 + eta..v ~ 0.0191298379535425 + }) + model({ + cl <- exp(t.cl + eta..cl) + v <- exp(t.v + eta..v) + linCmt() ~ add(add..sd) + }) + } - # no thetas + m6 <- m6() - m5 <- function() { - ini({ - t.cl <- c(-Inf, 1.01211464338867, 4.60517018598809) - label("Log Cl") - t.v <- 3.46039743010498 - label("log V") - add..sd <- c(0, 0.694761430696633) - eta.cl ~ 0.069154564934726 - eta.v ~ 0.0191298379535425 - }) - model({ - cl <- exp(t.cl + eta.cl) - v <- exp(t.v + eta.v) - linCmt() ~ add(add..sd) - }) - } + expect_equal(testPipeQuote(m6, iniDf=m1$iniDf), + list()) - m5 <- m5() + expect_equal(testPipeQuote(m1, iniDf=m6$iniDf), + list()) + }) + test_that("model piping that shares err parameter#427", { + u <- function() { + ini({ + b <- 3 + err.sd <- 2 + }) + model({ + a <- x + err.sd + c <- 1+b + c ~ add(err.sd) + }) + } - expect_equal(testPipeQuote(m5, iniDf=m1$iniDf), - list(quote(eta.cl ~ 0.069154564934726), - quote(eta.v ~ 0.0191298379535425))) + expect_error(u %>% model(-a), NA) + }) - expect_equal(testPipeQuote(m1, iniDf=m5$iniDf), - list(quote(eta.cl ~ 0.069154564934726), - quote(eta.v ~ 0.0191298379535425))) + test_that("adding a constant does not add to the ini block", { + u <- function() { + ini({ + b <- 3 + err.sd <- 2 + }) + model({ + a <- x + err.sd + c <- 1+b + c ~ add(err.sd) + }) + } + n <- u %>% model(aa <- pi+4, append=c) - m6 <- function() { - ini({ - t.cl <- c(-Inf, 1.01211464338867, 4.60517018598809) - label("Log Cl") - t.v <- 3.46039743010498 - label("log V") - add..sd <- c(0, 0.694761430696633) - eta..cl ~ 0.069154564934726 - eta..v ~ 0.0191298379535425 - }) - model({ - cl <- exp(t.cl + eta..cl) - v <- exp(t.v + eta..v) - linCmt() ~ add(add..sd) - }) - } + expect_false(any(n$iniDf$name == "pi")) + }) - m6 <- m6() + test_that("adding a line with a defined constant doesn't add to ini()", { + u <- function() { + ini({ + b <- 3 + err.sd <- 2 + }) + model({ + a <- x + err.sd + aa <- 3 + c <- 1+b + c ~ add(err.sd) + }) + } - expect_equal(testPipeQuote(m6, iniDf=m1$iniDf), - list()) + n <- u %>% model(aaa <- aa+4, append=c) - expect_equal(testPipeQuote(m1, iniDf=m6$iniDf), - list()) + expect_false(any(n$iniDf$name == "aa")) + }) }) - test_that("model piping that shares err parameter#427", { - u <- function() { + + + test_that("test ui appending of derived variables like `sim` can work", { + + one.compartment <- function() { ini({ - b <- 3 - err.sd <- 2 + tka <- 0.45 + tcl <- 1 + tv <- 3.45 + eta.ka ~ 0.6 + eta.cl ~ 0.3 + eta.v ~ 0.1 + add.err <- 0.7 }) model({ - a <- x + err.sd - c <- 1+b - c ~ add(err.sd) + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d / dt(depot) <- -ka * depot + d / dt(center) <- ka * depot - cl / v * center + cp <- center / v + cp ~ add(add.err) }) } - expect_error(u %>% model(-a), NA) + f <- rxode2(one.compartment) + + expect_error(model(f$simulationModel, sim2=sim+1, append=sim), NA) + }) - test_that("adding a constant does not add to the ini block", { - u <- function() { + + test_that("off-diagonal piping issue #518", { + + mod <- function() { ini({ - b <- 3 - err.sd <- 2 + a <- 1 + b <- 2 + etaa + etab ~ c(3, 0.1, 4) + c <- 5 + etac ~ 6 + d <- 7 + f <- 9 + etad + etaf ~ c(8, 0.2, 10) }) model({ - a <- x + err.sd - c <- 1+b - c ~ add(err.sd) + g <- (a + etaa)/(b + etab) + h <- (c + etac) + i <- (d + etad) + j <- f + etaf }) } - n <- u %>% model(aa <- pi+4, append=c) + modNew <- + ini( + rxode2(mod), + etab + etac + etad ~ + c(7, + 0.2, 8, + 0.3, 0.4, 9), + etaa ~ 0 + ) + + expect_error(modNew$omega, NA) - expect_false(any(n$iniDf$name == "pi")) }) - test_that("adding a line with a defined constant doesn't add to ini()", { - u <- function() { + test_that("piping append", { + + mod <- function() { ini({ - b <- 3 - err.sd <- 2 + tka <- 0.45 + label("Ka") + tcl <- 1 + label("Cl") + tv <- 3.45 + label("V") + add.sd <- c(0, 0.7) + eta.cl ~ 0.3 + eta.v ~ 0.1 }) model({ - a <- x + err.sd - aa <- 3 - c <- 1+b - c ~ add(err.sd) + ka <- exp(tka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d/dt(depot) = -ka * depot + d/dt(center) = ka * depot - cl/v * center + cp = center/v + cp ~ add(add.sd) }) } - n <- u %>% model(aaa <- aa+4, append=c) - - expect_false(any(n$iniDf$name == "aa")) - }) -}) - - -test_that("test ui appending of derived variables like `sim` can work", { - - one.compartment <- function() { - ini({ - tka <- 0.45 - tcl <- 1 - tv <- 3.45 - eta.ka ~ 0.6 - eta.cl ~ 0.3 - eta.v ~ 0.1 - add.err <- 0.7 - }) - model({ - ka <- exp(tka + eta.ka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d / dt(depot) <- -ka * depot - d / dt(center) <- ka * depot - cl / v * center - cp <- center / v - cp ~ add(add.err) - }) - } - - f <- rxode2(one.compartment) + t <- c("-cp","-d/dt(depot)") + expect_error(mod |> model(t), NA) - expect_error(model(f$simulationModel, sim2=sim+1, append=sim), NA) + t <- c("cp <- NULL","d/dt(depot) = NULL") + expect_error(mod |> model(t), NA) -}) + t <- c("cp <- NULL","d/dt(depot) ~ NULL") + expect_error(mod |> model(t), NA) + mod5 <- mod |> + model({ + PD <- 1-emax*cp/(ec50+cp) + ## + effect(0) <- e0 + kin <- e0*kout + d/dt(effect) <- kin*PD -kout*effect + }, append=d/dt(center)) -test_that("off-diagonal piping issue #518", { + expect_equal(mod5$theta, c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7)) - mod <- function() { - ini({ - a <- 1 - b <- 2 - etaa + etab ~ c(3, 0.1, 4) - c <- 5 - etac ~ 6 - d <- 7 - f <- 9 - etad + etaf ~ c(8, 0.2, 10) - }) - model({ - g <- (a + etaa)/(b + etab) - h <- (c + etac) - i <- (d + etad) - j <- f + etaf - }) - } + mod5 <- mod |> + model({ + PD <- 1-emax*cp/(ec50+cp) + ## + effect(0) <- e0 + kin <- e0*kout + d/dt(effect) <- kin*PD -kout*effect + }, append="d/dt(center)") - modNew <- - ini( - rxode2(mod), - etab + etac + etad ~ - c(7, - 0.2, 8, - 0.3, 0.4, 9), - etaa ~ 0 - ) + expect_equal(mod5$theta, c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7)) - expect_error(modNew$omega, NA) + mod6 <- mod5 |> + model({ + emax <- exp(temax) + e0 <- exp(te0 + eta.e0) + ec50 <- exp(tec50) + kin <- exp(tkin) + kout <- exp(tkout) + }, append=NA) + + expect_equal(mod6$theta, + c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7, temax = 1, te0 = 1, tec50 = 1, tkin = 1, tkout = 1)) + + expect_equal( + mod6$omega, + lotri({ + eta.cl ~ 0.3 + eta.v ~ 0.1 + eta.e0 ~ 1 + })) -}) + mod6 <- mod5 |> + model({ + emax <- exp(temax) + e0 <- exp(te0 + eta.e0) + ec50 <- exp(tec50) + kin <- exp(tkin) + kout <- exp(tkout) + }, append=FALSE) + + expect_equal( + mod6$omega, + lotri({ + eta.cl ~ 0.3 + eta.v ~ 0.1 + eta.e0 ~ 1 + })) -test_that("piping append", { - - mod <- function() { - ini({ - tka <- 0.45 - label("Ka") - tcl <- 1 - label("Cl") - tv <- 3.45 - label("V") - add.sd <- c(0, 0.7) - eta.cl ~ 0.3 - eta.v ~ 0.1 - }) - model({ - ka <- exp(tka) - cl <- exp(tcl + eta.cl) - v <- exp(tv + eta.v) - d/dt(depot) = -ka * depot - d/dt(center) = ka * depot - cl/v * center - cp = center/v - cp ~ add(add.sd) - }) - } + expect_equal(mod6$theta, + c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7, temax = 1, te0 = 1, tec50 = 1, tkin = 1, tkout = 1)) - t <- c("-cp","-d/dt(depot)") - expect_error(mod |> model(t), NA) - - t <- c("cp <- NULL","d/dt(depot) = NULL") - expect_error(mod |> model(t), NA) - - t <- c("cp <- NULL","d/dt(depot) ~ NULL") - expect_error(mod |> model(t), NA) - - mod5 <- mod |> - model({ - PD <- 1-emax*cp/(ec50+cp) - ## - effect(0) <- e0 - kin <- e0*kout - d/dt(effect) <- kin*PD -kout*effect - }, append=d/dt(center)) - - expect_equal(mod5$theta, c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7)) - - mod5 <- mod |> - model({ - PD <- 1-emax*cp/(ec50+cp) - ## - effect(0) <- e0 - kin <- e0*kout - d/dt(effect) <- kin*PD -kout*effect - }, append="d/dt(center)") - - expect_equal(mod5$theta, c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7)) - - mod6 <- mod5 |> - model({ - emax <- exp(temax) - e0 <- exp(te0 + eta.e0) - ec50 <- exp(tec50) - kin <- exp(tkin) - kout <- exp(tkout) - }, append=NA) - - expect_equal(mod6$theta, - c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7, temax = 1, te0 = 1, tec50 = 1, tkin = 1, tkout = 1)) - - expect_equal( - mod6$omega, - lotri({ - eta.cl ~ 0.3 - eta.v ~ 0.1 - eta.e0 ~ 1 - })) - - mod6 <- mod5 |> - model({ - emax <- exp(temax) - e0 <- exp(te0 + eta.e0) - ec50 <- exp(tec50) - kin <- exp(tkin) - kout <- exp(tkout) - }, append=FALSE) - - expect_equal( - mod6$omega, - lotri({ - eta.cl ~ 0.3 - eta.v ~ 0.1 - eta.e0 ~ 1 - })) - - expect_equal(mod6$theta, - c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7, temax = 1, te0 = 1, tec50 = 1, tkin = 1, tkout = 1)) - - mod6 <- mod5 |> - model({ - emax <- exp(temax) - e0 <- exp(te0 + eta.e0) - ec50 <- exp(tec50) - kin <- exp(tkin) - kout <- exp(tkout) - }, append=0) - - expect_equal( - mod6$omega, - lotri({ - eta.cl ~ 0.3 - eta.v ~ 0.1 - eta.e0 ~ 1 - })) - - expect_equal(mod6$theta, - c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7, temax = 1, te0 = 1, tec50 = 1, tkin = 1, tkout = 1)) - - # make sure auto model piping turns off - - withr::with_options(list(rxode2.autoVarPiping=FALSE), - mod7 <- mod5 |> - model({ - emax <- exp(temax) - e0 <- exp(te0 + eta.e0) - ec50 <- exp(tec50) - kin <- exp(tkin) - kout <- exp(tkout) - }, append=NA)) - - expect_equal(mod7$theta, - c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7)) - - expect_equal( - mod7$omega, - lotri({ - eta.cl ~ 0.3 - eta.v ~ 0.1 - })) + mod6 <- mod5 |> + model({ + emax <- exp(temax) + e0 <- exp(te0 + eta.e0) + ec50 <- exp(tec50) + kin <- exp(tkin) + kout <- exp(tkout) + }, append=0) + + expect_equal( + mod6$omega, + lotri({ + eta.cl ~ 0.3 + eta.v ~ 0.1 + eta.e0 ~ 1 + })) + + expect_equal(mod6$theta, + c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7, temax = 1, te0 = 1, tec50 = 1, tkin = 1, tkout = 1)) + + # make sure auto model piping turns off + + withr::with_options(list(rxode2.autoVarPiping=FALSE), + mod7 <- mod5 |> + model({ + emax <- exp(temax) + e0 <- exp(te0 + eta.e0) + ec50 <- exp(tec50) + kin <- exp(tkin) + kout <- exp(tkout) + }, append=NA)) + + expect_equal(mod7$theta, + c(tka = 0.45, tcl = 1, tv = 3.45, add.sd = 0.7)) + + expect_equal( + mod7$omega, + lotri({ + eta.cl ~ 0.3 + eta.v ~ 0.1 + })) + }) }) diff --git a/tests/testthat/test-ui-param.R b/tests/testthat/test-ui-props.R similarity index 78% rename from tests/testthat/test-ui-param.R rename to tests/testthat/test-ui-props.R index dd94739f7..44ef91379 100644 --- a/tests/testthat/test-ui-param.R +++ b/tests/testthat/test-ui-props.R @@ -1,5 +1,5 @@ if (!.Call(`_rxode2_isIntel`)) { - test_that("ui params", { + test_that("ui props", { fun_odes <- function() { description <- "Dupilumab PK model (Kovalenko 2020)" @@ -108,7 +108,7 @@ if (!.Call(`_rxode2_isIntel`)) { obj_ana = rxode2(fun_ana) obj_odes = rxode2(fun_odes) - expect_equal(obj_ana$params, + expect_equal(obj_ana$props, list(pop = c("lfdepot", "lka", "lcl", "lv", "lvp", "lq", "allocl", "allov"), resid = "prop.err", group = list(id = c("etafdepot", "etaka", "etacl", "etav", "etavp", "etaq")), @@ -117,9 +117,10 @@ if (!.Call(`_rxode2_isIntel`)) { output = list(primary = c("fdepot", "ka", "wtnorm", "cl", "q", "v", "vp"), secondary = character(0), endpoint = "Cc", - state = character(0)))) + state = character(0)), + cmtProp=NULL)) - expect_equal(obj_odes$params, + expect_equal(obj_odes$props, list(pop = c("lvc", "lke", "lkcp", "Mpc", "lka", "lMTT", "lVm", "Km", "lfdepot", "e_wt_vc"), resid = c("cppropSd", "cpaddSd"), group = list(id = c("etalvc", "etalke", "etalka", "etalvm", "etamtt")), @@ -128,7 +129,8 @@ if (!.Call(`_rxode2_isIntel`)) { output = list(primary = c("vc", "ke", "kcp", "ka", "MTT", "Vm", "kpc"), secondary = "ktr", endpoint = "Cc", - state = c("depot", "transit1", "transit2", "transit3", "central", "periph")))) + state = c("depot", "transit1", "transit2", "transit3", "central", "periph")), + cmtProp=data.frame(Compartment="depot", Property="f"))) fun_ana2 <- function() { @@ -171,7 +173,7 @@ if (!.Call(`_rxode2_isIntel`)) { tmp <- fun_ana2() - expect_equal(tmp$params, + expect_equal(tmp$props, list(pop = c("lfdepot", "lka", "lcl", "lv", "lvp", "lq", "allocl", "allov"), resid = "prop.err", group = list(id = c("etafdepot", "etaka", "etacl", "etav", "etavp", "etaq")), @@ -180,7 +182,8 @@ if (!.Call(`_rxode2_isIntel`)) { output = list(primary = c("fdepot", "ka", "wtnorm", "cl", "q", "v", "vp"), secondary = character(0), endpoint = character(0), - state = character(0)))) + state = character(0)), + cmtProp=NULL)) }) @@ -200,9 +203,9 @@ if (!.Call(`_rxode2_isIntel`)) { mod <- mod() - expect_error(mod$params, NA) + expect_error(mod$props, NA) - expect_equal(mod$params, + expect_equal(mod$props, list(pop = c("cl", "vc"), resid = "err.sd", group = structure(list(), names = character(0)), @@ -211,7 +214,47 @@ if (!.Call(`_rxode2_isIntel`)) { output = list(primary = character(0), secondary = character(0), endpoint = "Cc", - state = character(0)))) + state = character(0)), + cmtProp=NULL)) }) + + test_that("state based endpoint", { + + oncology_sdm_lobo_2002 <- function() { + description <- "Signal transduction model for delayed concentration effects on cancer cell growth" + reference <- "Lobo ED, Balthasar JP. Pharmacodynamic modeling of chemotherapeutic effects: Application of a transit compartment model to characterize methotrexate effects in vitro. AAPS J. 2002;4(4):212-222. doi:10.1208/ps040442" + depends<-"Cc" + units<-list(time="hr") + # Values for lkng, ltau, lec50, and kmax are for methotrexate from Lobo 2002, + # Table 2. propErr and addErr are added as reasonable values though not from + # Lobo 2002 where no value is apparent in the paper. + ini({ + lkng <- log(0.02) ; label("Cell net growth rate (growth minus death) (1/hr)") + ltau <- log(34.1) ; label("Mean transit time of each transit compartment (hr)") + lec50 <- log(0.1) ; label("Drug concentration reducing the cell growth by 50% (ug/mL)") + kmax <- 0.29 ; label("Maximum drug-related reduction in cell growth (1/hr)") + tumorVolpropSd <- c(0, 0.3) ; label("Proportional residual error (fraction)") + tumorVoladdSd <- c(0, 50, 1000) ; label("Additive residual error (tumor volume units)") + }) + model({ + # Cc is the drug concentration + kng <- exp(lkng) + tau <- exp(ltau) + ec50 <- exp(lec50) + drugEffectTumorVol <- kmax*Cc/(ec50 + Cc) + tumorVol(0) <- tumorVol0 + d/dt(tumorVol) <- kng*tumorVol - transit4*tumorVol + d/dt(transit1) <- (drugEffectTumorVol - transit1)/tau + d/dt(transit2) <- (transit1 - transit2)/tau + d/dt(transit3) <- (transit2 - transit3)/tau + d/dt(transit4) <- (transit3 - transit4)/tau + tumorVol ~ prop(tumorVolpropSd) + add(tumorVoladdSd) + }) + } + + rx_obj = rxode2::rxode2(oncology_sdm_lobo_2002) + + expect_equal(rx_obj$props$output$endpoint, "tumorVol") + }) } diff --git a/vignettes/articles/Integrating-User-Defined-Functions-into-rxode2.Rmd b/vignettes/articles/Integrating-User-Defined-Functions-into-rxode2.Rmd index 548878da8..8aaf83682 100644 --- a/vignettes/articles/Integrating-User-Defined-Functions-into-rxode2.Rmd +++ b/vignettes/articles/Integrating-User-Defined-Functions-into-rxode2.Rmd @@ -17,13 +17,16 @@ library(rxode2) When defining models you may have wished to write a small R function or make a function integrate into `rxode2` somehow. This article -discusses 2 ways to do this: +discusses 4 ways to do this: -- A R-based user function which can be loaded as a simple function - or in certain circumstances translated to C to run more - efficiently +- A R-based user function which can be loaded as a simple function or + in certain circumstances translated to C to run more efficiently -- A C function that you define and integrate into code +- A C function that you define and integrate into code + +- A user defined function that changes `rxode2` ui code by replacing + the function with `rxode2` code. This can be in the presence or + absence of the data for simulation or estimation. ## R based user functions @@ -203,3 +206,271 @@ table: ```{r rxDrm} rxRmFun("fun") ``` + +## Functions to insert `rxode2` code into the current model + +This replaces `rxode2` code in the current model with some expansion. +This can allow more R-like functions inside of the rxode2 ui models, +as well as adding approximating functions like polynomials, splines +and neural networks. + +An example that allows more `R`-like functions is below: + +```r +f <- function() { + model({ + a <- rxpois(lambda=lam) + }) +} + +# Which will evaluate into a standard rxode2 function that does not +# support named arguments (since it is translated to C) +f() + +# Which is still true in the standard rxode2: + +try(rxode2({ + a <- rxpois(lambda=lam) +})) +``` + +This is accomplished by a combination of two functions, which are +highly commented: + +``` r +rxUdfUi.rxpois <- function(fun) { + # Fun is the language object (ie quoted R object) to be evaluated or + # changed in the code + .fun <- fun + # Since the `rxpois` function is built into the rxode2 we need to + # have a function with a different conflicts. In this case, I take + # the function name (fun[[1]]), and prepend a ".", which follows + # `rxode2`'s naming convention of un-exported functions. + # + # This next evaluation changes the expression function to .rxpois() + .fun[[1]] <- str2lang(paste0(".", deparse1(fun[[1]]))) + # Since this is still a R expression, you can then evaluate the + # function .rxpois to produce the proper code: + eval(.fun) +} + +# The above s3 method can be registered in a package or you can use +# the following code to register it in your session: +rxode2::.s3register("rxode2::rxUdfUi", "rxpois") + +# This is the function that changes the code as needed +.rxpois <- function(lambda) { + # The first part of this code tries to change the value into a + # character. This handles cases like rxpois(lambda=lam), + # rxpois(lam), rxpois("lam"). It also tries to evaluate the + # argument supplied to lambda in case it comes from a different + # location. + .lam <- as.character(substitute(lambda)) + .tmp <- try(force(lambda), silent=TRUE) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .lam <- lambda + } + } + # This part creates a list with the replacement text, in this case + # it woulb be rxpois(lam) where there is no equals included, as + # required by `rxode2`: + list(replace=paste0("rxpois(", .lam, ")")) +} + +``` + +In general the list that the function needs to return can have: + +- `$replace` -- The text that will be replaced + +- `$before` -- lines that will be placed in the model before the + current function is found + +- `$after` -- lines that are added in the model after the current + function is found + +- `$iniDf` -- the initial estimates `data.frame` for this problem. + While calling this function, you can retrieve the initial conditions + currently used parsing you can get the prior value with + `rxUdfUiIniDf()` and then you can modify it inside the function and + return the new `data.frame` in this list element. This allows you + add/delete initial estimates from the model as well as modify the + model lines themselves. + +- `$uiUseData` -- when `TRUE`, this instructs `rxode2` and + `nlmixr2est` to re-parse this function in the presence of data, this + means a bit more function setup will need to be done. + +- `$uiUseMv` -- when `TRUE` this instructs `rxode2` to re-parse the + function after the initial model variables are calculated. + +In addition to the `rxUdfUiIniDf()` you can get information about the +parser: + +- `rxUdfUiParsing()` returns if the rxode2 ui function is being parsed + currently (this allows a function to be overloaded as a `udf` for + calling from `rxode2` as well as a function for modifying the + model). + +- `rxUdfUiNum()` during parsing the function you are calling (in the + example above `rxpois()` can be called multiple times. This gives + the number of the function in the model in order (the first would + give `1` the second, `2`, etc). This can be used to create unique + variables with functions like `rxIntToLetter()` or `rxIntToBase()`. + +- `rxUdfUiIniLhs()` which gives the left-handed side of the equation + where the function is found. This is also a `R` language object. + +- `rxUdfUiIniMv()` gives the model variables for parsing (can be used + in functions like `linCmt()`) + +- `rxUdfUiData()` which specifies the data that are being used to + simulate, estimate, etc. + +- `rxUdfUiEst()` which gives the estimation/simulation method that is + being used with the model. For example, with simulation it would be + `rxSolve`. + +### Using model variables in `rxode2` ui models + +You can also take and change the model and take into consideration the +`rxode2` model variables before the full `ui` has completed its +parsing. These `rxode2` model variables has information that might +change what variables you make or names of variables. For example it +has what is on the left hand side of the equations (`$lhs`), what are +the input parameters (`$params`) and what is the ODE states +(`$state`)). + +If you are using this approach, you will likely need to do the +following steps: + +- When data are not being processed, you need to put the function in + an `rxode2` acceptable form, no named arguments, no strings, and + only numbers or variables in the output. + +- The number of arguments of this output needs to be declared in the + `S3` method by adding the attribute `"nargs"` to method. For + example, the built in `testMod1()` ui modification function uses + only one argument when parsed + +Below is a commented example of the model variables example: + +```{r rxModelVarsUiModel} + +testMod1 <- function(val=1) { + # This converts the val to a character if it is somthing like testMod1(b) + .val <- as.character(substitute(val)) + .tmp <- suppressWarnings(try(force(val), silent = TRUE)) + if (!inherits(.tmp, "try-error")) { + if (is.character(.tmp)) { + .val <- val + } + } + # This does the UI parsing + if (rxUdfUiParsing()) { + # See if the model variables are available + .mv <- rxUdfUiMv() + if (is.null(.mv)) { + # Put this in a rxode2 low level acceptible form, no complex + # expressions, no named arguments, something that is suitable + # for C. + # + # The `uiUsMv` tells the parser this needs to be reparsed when + # the model variables become avaialble during parsing. + return(list(replace=paste0("testMod1(", .val, ")"), + uiUseMv=TRUE)) + } else { + # Now that we have the model variables, we can then do something + # about this + .vars <- .mv$params + if (length(.vars) > 0) { + # If there is parameters available, this dummy function times + # the first input function by the value specified + return(list(replace=paste0(.vars[1], "*", .val))) + } else { + # If the value isn't availble, simply replace the function + # with the value. + return(list(replace=.val)) + } + } + } + stop("This function is only for use in rxode2 ui models", + call.=FALSE) + +} + +rxUdfUi.testMod1 <- function(fun) { + eval(fun) +} + +# To allow this to go to the next step, you need to declare how many +# arguments this argument has, in this case 1. Bu adding the +# attribute "nargs", rxode2 lower level parser knows how to handle +# this new function. This allows rxode2 to generate the model +# variables and send it to the next step. + +attr(rxUdfUi.testMod1, "nargs") <- 1L + +# If you are in a package, you can use the rxoygen tag @export to +# register this as a rxode2 model definition. +# +# If you are using this in your own script, you need to register the s3 function +# One way to do this is: +rxode2::.s3register("rxode2::rxUdfUi", "testMod1") + +## These are some examples of this function in use: + +f <- function() { + model({ + a <- b + testMod1(3) + }) +} + +f <- f() + +print(f) + +f <- function() { + model({ + a <- testMod1(c) + }) +} + +f <- f() + +print(f) + +f <- function() { + model({ + a <- testMod1(1) + }) +} + +f <- f() + +print(f) + +``` + +### Using data for `rxode2` ui modification models + +The same steps are needed to use the data in the model replacement; +You can then use the data and the model to replace the values inside +the model. A worked example `linMod()` is included +that has the ability to use: + +- model variables, +- put lines before or after the model, +- add initial conditions +- And use data in the initial estimates + +```{r linMod} + +# You can print the code: +linMod + +# You can also print the s3 method that is used for this method + +rxode2:::rxUdfUi.linMod +``` diff --git a/vignettes/articles/Modifying-Models.Rmd b/vignettes/articles/Modifying-Models.Rmd index ff8fd7f00..b421ee44e 100644 --- a/vignettes/articles/Modifying-Models.Rmd +++ b/vignettes/articles/Modifying-Models.Rmd @@ -502,6 +502,8 @@ The common items you want to do with initial estimates are: - Reorder parameters +- Remove covariances between all parameters or a group of parameters + You may wish to create your own functions; we will discuss this too. @@ -830,6 +832,49 @@ f8 <- f |> print(f8) ``` +### Removing covariances between between subject varaibilities + +There are two approaches to removing covarinaces for between subject +variabilities: `diag()` and `-cov(var1, var2)` + +The `diag()` removes either all covariance elements (with no +arguments) or any covariance elements included in the argument list: + +```{r diagExamples} +fd <- function() { + ini({ + tka <- 0.45 + tcl <- 1 + tv <- 3.45 + add.sd <- c(0, 0.7) + eta.ka ~ 0.6 + eta.v ~ c(0.01, 0.1) + eta.cl ~ c(0.01, 0.01, 1) + }) + model({ + ka <- exp(tka + eta.ka) + cl <- exp(tcl + eta.cl) + v <- exp(tv + eta.v) + d/dt(depot) <- -ka * depot + d/dt(center) <- ka * depot - cl/v * center + cp <- center/v + cp ~ add(add.sd) + }) +} + +# If you want to remove all covariances you can use diag() with no +# arguments + +fd %>% ini(diag()) + +# if you want to remove only covariances with eta.ka you can use: +fd %>% ini(diag(eta.ka)) + +# if you want to remove only the covariances with eta.ka and eta.v you can use: +fd %>% ini(-cov(eta.ka, eta.v)) + +``` + ### More granular access of initial conditions Just like with `model()` you can modify the underlying data frame that diff --git a/vignettes/rxode2-syntax.Rmd b/vignettes/rxode2-syntax.Rmd index 3583a590f..026a6a1f2 100644 --- a/vignettes/rxode2-syntax.Rmd +++ b/vignettes/rxode2-syntax.Rmd @@ -13,11 +13,12 @@ vignette: > knitr::opts_chunk$set( collapse = TRUE, comment = "#>") +library(rxode2) ``` ## Introduction -This briefly describes the syntax used to define models +This briefly describes the syntax used to define models that `rxode2` will translate into R-callable compiled code. It also describes the communication of variables between `R` and the `rxode2` modeling specification. @@ -35,7 +36,7 @@ describes the communication of variables between `R` and the ## Bugs and/or deficiencies -- The modulo operator `%%` is currently unsupported. +- The modulo operator `%%` is currently unsupported. ## Note @@ -49,10 +50,10 @@ Below is a commented example to quickly show the capabilities of ## Example -```{r} +``` r f <- function() { ini({ - + }) model({ # An rxode2 model specification (this line is a comment). @@ -86,18 +87,18 @@ via the `d/dt(identifier)` operator as part of the model specification, and which are model parameters via the `params=` argument in `rxode2` `solve()` method: -``` +``` r m1 <- rxode2(model = ode, modName = "m1") # model parameters -- a named vector is required -theta <- +theta <- c(KA=0.29, CL=18.6, V2=40.2, Q=10.5, V3=297, Kin=1, Kout=1, EC50=200) # state variables and their amounts at time 0 (the use of names is # encouraged, but not required) inits <- c(depot=0, centr=0, peri=0, eff=1) -# qd1 is an eventTable specification with a set of dosing and sampling +# qd1 is an eventTable specification with a set of dosing and sampling # records (code not shown here) solve(theta, event = qd1, inits = inits)