nanotime/0000755000176200001440000000000014325434233012067 5ustar liggesusersnanotime/NAMESPACE0000644000176200001440000000514514211166045013310 0ustar liggesusersuseDynLib(nanotime, .registration = TRUE) import("methods") import("bit64") importFrom("RcppCCTZ", "parseDouble", "formatDouble") importFrom("zoo", "index2char") importFrom("utils", "head", "tail") S3method(as.Date,nanotime) S3method(as.POSIXct,nanotime) S3method(as.POSIXlt,nanotime) S3method(as.data.frame,nanotime) S3method(as.integer64,nanotime) S3method(format,nanotime) S3method(as.character,nanotime) S3method(index2char,nanotime) S3method(c,nanotime) export(NA_nanotime_) export(NA_nanoduration_) export(NA_nanoival_) export(NA_nanoperiod_) export(as.nanotime) export(nanotime.matrix) exportClasses(nanotime) exportMethods("+") exportMethods("-") exportMethods("[[") exportMethods("[") exportMethods("[<-") exportMethods(Arith) exportMethods(Compare) exportMethods(Complex) exportMethods(Logic) exportMethods(Math) exportMethods(Math2) exportMethods(Summary) exportMethods(max) exportMethods(min) exportMethods(nanotime) exportMethods(as.nanotime) exportMethods(print) exportMethods(range) exportMethods(show) exportMethods("names<-") exportMethods(is.na) exportMethods(as.nanoduration) exportMethods(show) exportMethods(print) exportMethods(plus) exportMethods(minus) exportMethods(intersect.idx) exportMethods(intersect) exportMethods(union) exportMethods(setdiff.idx) exportMethods(setdiff) exportMethods(as.nanoival) exportClasses(nanoival) export(nanoival) exportMethods(nanoival.start) exportMethods(nanoival.end) exportMethods(nanoival.sopen) exportMethods(nanoival.eopen) exportMethods(print) exportMethods(show) exportMethods(names) exportMethods("names<-") exportMethods("<") exportMethods("<=") exportMethods(">") exportMethods(">=") exportMethods("[") exportMethods("[<-") exportMethods("is.na") exportMethods("is.na<-") S3method(c, nanoival) exportMethods(t) exportMethods(is.unsorted) exportMethods(sort) S3method(seq, nanotime) exportMethods(seq) exportMethods(all.equal) S3method(all.equal, nanotime) exportClasses(nanoperiod) export(nanoperiod) exportMethods(as.nanoperiod) exportMethods(nanoperiod.month) exportMethods(nanoperiod.day) exportMethods(nanoperiod.nanoduration) S3method(c, nanoperiod) exportClasses(nanoduration) export(nanoduration) S3method(as.integer64,nanoduration) exportMethods(as.nanoduration) S3method(c, nanoduration) S3method(as.data.frame,nanoduration) S3method(seq, nanoduration) S3method(format,nanoival) S3method(format,nanoduration) S3method(format,nanoperiod) S3method(as.character,nanoival) exportMethods(nano_wday) exportMethods(nano_mday) exportMethods(nano_month) exportMethods(nano_year) exportMethods(nano_ceiling) exportMethods(nano_floor) S3method("%in%", nanotime) exportMethods("%in%") nanotime/demo/0000755000176200001440000000000013727036105013014 5ustar liggesusersnanotime/demo/ggplot2Example.R0000644000176200001440000001655213727036105016042 0ustar liggesusersif (requireNamespace("ggplot2", quietly=TRUE) && requireNamespace("scales", quietly=TRUE) && requireNamespace("data.table", quietly=TRUE)) { library(nanotime) library(ggplot2) library(scales) library(data.table) nanotime_breaks <- function(n=5) function(x) nanotime(pretty_breaks(n)(as.numeric(x))) nanotime_format <- function(format = getOption("nanotimeFormat", default="%Y-%m-%dT%H:%M:%EXS%Ez"), tz = getOption("nanotimeTz", default="UTC")) { function(x) format(x, format, tz=tz) } nanotime_trans <- function(tz = NULL) { to_time <- function(x) { nanotime(x) } from_time <- function(x) { if (!inherits(x, "nanotime")) { stop("Invalid input: nanotime_trans works with objects of class ", "nanotime only", call. = FALSE) } structure(as.numeric(x), names = names(x)) } trans_new("nanotime", "from_time", "to_time", breaks=nanotime_breaks(), format=nanotime_format(tz=tz)) } is.waive <- function(x) inherits(x, "waiver") ScaleContinuousNanotime <- ggproto("ScaleContinuousNanotime", ScaleContinuous, secondary.axis = waiver(), timezone = NULL, transform = function(self, x) { ggproto_parent(ScaleContinuous, self)$transform(x) }, map = function(self, x, limits = self$get_limits()) { self$oob(x, limits) }, break_info = function(self, range = NULL) { breaks <- ggproto_parent(ScaleContinuous, self)$break_info(range) if (!(is.waive(self$secondary.axis) || self$secondary.axis$empty())) { self$secondary.axis$init(self) breaks <- c(breaks, self$secondary.axis$break_info(breaks$range, self)) } breaks }, sec_name = function(self) { if (is.waive(self$secondary.axis)) { waiver() } else { self$secondary.axis$name } }, make_sec_title = function(self, title) { if (!is.waive(self$secondary.axis)) { self$secondary.axis$make_title(title) } else { ggproto_parent(ScaleContinuous, self)$make_sec_title(title) } }) scale_type.nanotime <- function(x) "nanotime" nanotime_scale <- function(aesthetics, trans, palette, breaks = pretty_breaks(), minor_breaks = waiver(), labels = waiver(), date_breaks = waiver(), date_labels = waiver(), date_minor_breaks = waiver(), timezone = NULL, guide = "legend", ...) { continuous_scale( aesthetics, "nanotime", palette = palette, breaks = breaks, minor_breaks = minor_breaks, labels = labels, guide = guide, trans = trans, ..., super = ScaleContinuousNanotime )} ## copy from `ggplot2` a function that is not exported: set_sec_axis <- function(sec.axis, scale) { if (!is.waive(sec.axis)) { if (is.formula(sec.axis)) sec.axis <- sec_axis(sec.axis) if (!is.sec_axis(sec.axis)) abort("Secondary axes must be specified using 'sec_axis()'") scale$secondary.axis <- sec.axis } return(scale) } ## `ggplot2` code will location these functions by building a name with "scale_", "x" or "y", "_", "nanotime": scale_x_nanotime <- function(name = waiver(), breaks = waiver(), date_breaks = waiver(), labels = waiver(), date_labels = waiver(), minor_breaks = waiver(), date_minor_breaks = waiver(), timezone = NULL, limits = NULL, expand = waiver(), guide = waiver(), position = "bottom", sec.axis = waiver()) { sc <- nanotime_scale(aesthetics=c("x", "xmin", "xmax", "xend"), trans="nanotime", name = name, palette = identity, breaks = breaks, date_breaks = date_breaks, labels = labels, date_labels = date_labels, minor_breaks = minor_breaks, date_minor_breaks = date_minor_breaks, timezone = timezone, guide = guide, limits = limits, expand = expand, position = position ) set_sec_axis(sec.axis, sc) } scale_y_nanotime <- function(name = waiver(), breaks = waiver(), date_breaks = waiver(), labels = waiver(), date_labels = waiver(), minor_breaks = waiver(), date_minor_breaks = waiver(), limits = NULL, expand = waiver(), guide = waiver(), position = "left", sec.axis = waiver()) { nanotime_scale( aesthetics=c("y", "ymin", "ymax", "yend"), trans="nanotime", name = name, palette = identity, breaks = breaks, date_breaks = date_breaks, labels = labels, date_labels = date_labels, minor_breaks = minor_breaks, date_minor_breaks = date_minor_breaks, guide = guide, limits = limits, expand = expand, position = position ) } ## now, test the above: ## ------------------- ## create `data.table` with `idx` of type `nanotime`: idx <- nanotime(1) + 1e9*(1:100) dt <- data.table(idx=idx, a=1:100, b=11:110) ## nanotime on the x-axis: ggplot(dt, aes(x=idx, y=b)) + geom_line() ## nanotime on the y-axis: ggplot(dt, aes(x=b, y=idx)) + geom_line() ## change the format of the tick labels: ggplot(dt, aes(x=idx, y=b)) + geom_line() + scale_x_nanotime(labels=nanotime_format("%H:%M:%S")) ## change format and write tick labels diagonally: ggplot(dt, aes(x=idx, y=b)) + geom_line() + theme(axis.text.x = element_text(angle = 45, hjust = 1)) + scale_x_nanotime(labels = nanotime_format("%Y-%m-%d %H:%M:%S")) } nanotime/demo/nanosecondDelayExample.R0000644000176200001440000000266313035016762017567 0ustar liggesuserslibrary(nanotime) suppressMessages(library(data.table)) suppressMessages(library(ggplot2)) set.seed(42) N <- 300 rainyday <- ISOdatetime(2016,9,28,8,30,0) # made up shinyday <- ISOdatetime(2016,9,21,8,30,0) # made up too rdsent <- nanotime(rainyday) + cumsum(10*rpois(N, lambda=4)) # random sent time sdsent <- nanotime(shinyday) + cumsum(10*rpois(N, lambda=4)) # identical sent process for both rdrecv <- rdsent + 10*rlnorm(N, 0.30, 0.25) # postulate higher mean and sd sdrecv <- sdsent + 10*rlnorm(N, 0.10, 0.20) # for rainy than shiny raw <- data.table(rdsent, rdrecv, sdsent, sdrecv) raw[, `:=`(rainy=as.numeric(rdrecv-rdsent), shiny=as.numeric(sdrecv-sdsent))] ## melt into long format plotdata <- melt(raw[,.(rainy,shiny)], measure.vars=1:2, variable.name="day", value.name="time") ## and plot ggplot(plotdata, aes(day, time)) + geom_violin(aes(fill=day)) + coord_flip() + ylab("Message Time in Nanoseconds") + xlab("Weather Conditions") + ggtitle("Nanosecond Delay", "Under Different Weather Conditions") tfile <- tempfile(pattern="raw", fileext=".csv") fwrite(raw, file=tfile) cooked <- fread(tfile) ## csv files are not 'typed' so need to recover types explicitly cooked[, `:=`(rdsent=nanotime(rdsent), rdrecv=nanotime(rdrecv), sdsent=nanotime(sdsent), sdrecv=nanotime(sdrecv))] ## now saved and restrored data are identical all.equal(raw, cooked) nanotime/demo/00Index0000644000176200001440000000021013726676565014162 0ustar liggesusersnanosecondDelayExample Simulated example of network delay in nanoseconds ggplot2Example Plotting via ggplot2 from data.table objects nanotime/ChangeLog0000644000176200001440000006302714325355546013662 0ustar liggesusers2022-10-23 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.3.7 2022-10-16 Trevor L Davis * R/nanoduration.R: Add '+' / '-' methods for 'difftime()' and 'nanoduration()' / 'nanoival()' / 'nanotime()' objects * man/nanoduration.Rd: Updated * inst/tinytest/test_nanoduration.R: Add tests 2022-10-14 Trevor L Davis * R/nanoduration.R (as.nanoduration.difftime): Added * man/nanoduration.Rd: Updated * inst/tinytest/test_nanoduration.R: Add tests 2022-10-13 Trevor L Davis * R/nanoduration.R (nanoduration): Add default arguments equal to zero * R/nanotime.R: Use 'inherits()' instead of 'class() ==' 2022-10-04 Dirk Eddelbuettel * docs/mkdmt-src/: Updated for mkdocs-for-material 8.5.5 2022-03-06 Leonardo Silvestri * DESCRIPTION (Version, Date): Release 0.3.6 * R/nanoival.R: Fix incorrect subsetting with operator `%in%` * NAMESPACE: Added export * man/set_operations.Rd: Added file * src/period.cpp: Fix parse of negative period 2022-03-06 Dirk Eddelbuettel * R/nanoduration.R: Use 'inherits()' instead of 'class() ==' * R/nanoival.R: Idem * R/nanoperiod.R: Idem * R/nanotime.R: Idem 2021-12-14 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.3.5 2021-12-09 Dirk Eddelbuettel * src/Makevars.ucrt: Based on patch by Tomas Kalibera that is part of his changes for the Windows utf8-enhabced ucrt3 builds of R 4.2.0 2021-11-23 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.3.4 2021-11-21 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version 2021-11-21 Leonardo Silvestri * inst/include/nanotime/period.hpp: Regroup and expose nanoperiod interface for use by other packages * src/period.cpp: Moved code to period.hpp header * src/rounding.cpp: Idem 2021-11-17 Dirk Eddelbuettel * README.md: Remove Travis badge * .travis.yml: Remove Travis YAML config 2021-10-11 Dirk Eddelbuettel * R/nanoduration.R (all.equal.nanoduration): Remove as.character.nanotime as proper S4 method already defined * R/nanoperiod.R (all.equal.nanoperiod): Idem * NAMESPACE: Removed exports * man/nanoduration.Rd: Updated * man/nanoperiod.Rd: Idem * .codecov.yml (coverage): Ensure PRs will not get a red 'fail' just because coverage metrices dropped a miniscule amount 2021-10-10 Dirk Eddelbuettel * R/nanoival.R (as.character.nanoival): Added * NAMESPACE: Idem * man/nanoival.Rd: Aliases * R/nanoperiod.R (as.character.nanoperiod): Added * NAMESPACE: Idem * man/nanoperiod.Rd: Aliases * R/nanoduration.R (as.character.nanoduration): * NAMESPACE: Idem * man/nanoduration.Rd: Aliases * inst/tinytest/test_nanotime.R: Add tests * inst/tinytest/test_nanoival.R: Idem * inst/tinytest/test_nanoperiod.R: Idem 2021-10-08 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * R/nanotime.R (as.character.nanotime): Added * NAMESPACE: Idem * man/nanotime.Rd: Aliases 2021-08-09 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.3.3 2021-08-08 Leonardo Silvestri * src/period.cpp: Fix for `plus` and `minus` adjustment * R/nanoperiod.R: Idem * inst/tinytest/test_nanoperiod.R: Idem * man/nanoperiod.Rd: Idem 2021-04-06 Dirk Eddelbuettel * DESCRIPTION (URL, BugRreports): Added to DESCRIPTION file 2021-03-28 Dirk Eddelbuettel * docs/mkdmt-src/: Moved mkdocs-material input 2020-12-30 Dirk Eddelbuettel * .github/workflows/ci.yaml: Rename job from build to ci 2020-12-25 Dirk Eddelbuettel * .github/workflows/ci.yaml: Small tweaks to CI YAML file 2020-12-13 Dirk Eddelbuettel * README.md: Add CI badge 2020-12-06 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * .travis.yml: Switch to run.sh from r-ci for focal and bspm * .github/workflows/ci.yaml: Use run.sh from r-ci 2020-12-06 Colin Umansky * inst/tinytest/test_nanoduration.R: Added tests for comparison 2020-12-05 Colin Umansky * R/nanoduration.R: Support nanoduration to character comparison * man/nanoduration.Rd: Document new feature * inst/tinytest/test_nanoduration.R: Updated tests 2020-10-25 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * docker/r-devel/Dockerfile: Added for simpler r-devel checks 2020-10-24 Dirk Eddelbuettel * inst/tinytest/test_nanotime.R: Add explicit check.tzone=FALSE to equality test for POSIXct comparison * inst/tinytest/test_nanoival.R: Renable full tests, add bit64 * inst/tinytest/test_nanoperiod.R: Idem * inst/tinytest/test_nanotime.R: Idem * inst/tinytest/test_ops.R: Idem 2020-09-11 Dirk Eddelbuettel * docs/: Added package website * README.md: Added badge and short paragraph linking to documentation 2020-09-07 Leonardo Silvestri * demo/ggplot2Example.R: Updated and extended demo 2020-09-04 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * demo/ggplot2Example.R: New demo based on Leonardo's example repo 2020-09-03 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.3.2 2020-09-01 Elliott Sales de Andrade * inst/include/nanotime/interval.hpp: Correct for big-endian 2020-08-31 Dirk Eddelbuettel * .travis.yml (install): Back to RcppCCTZ from CRAN 2020-08-30 Dirk Eddelbuettel * R/nanoival.R: De-activate two examples * R/nanotime.R: Idem * man/nanoival.Rd: Idem * man/nanotime.Rd: Idem * inst/tinytest/test_nanoduration.R: Make some test conditional * inst/tinytest/test_nanoival.R: Idem * inst/tinytest/test_nanoperiod.R: Idem * inst/tinytest/test_nanotime.R: Idem * inst/tinytest/test_ops.R: Idem 2020-08-28 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * src/interval.cpp: Use RcppCCTZ_API header and exported functions * src/nanotime.cpp: Idem * src/period.cpp: Idem * src/rounding.cpp: Idem * .travis.yml (install): Install RcppCCTZ from GitHub 2020-08-09 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.3.1 * R/nanoival.R: Add \dontrun{} because of Solaris * R/nanoperiod.R: Idem * R/nanotime.R: Idem * man/nano_year.Rd: Idem * man/nanoperiod.Rd: Idem * man/nanotime.Rd: Idem * man/rounding.Rd: Idem * man/seq-nanoival-method.Rd: Idem * man/seq.nanotime.Rd: Idem * inst/tinytest/test_nanoival.R: Skip some tests on Solaris * inst/tinytest/test_nanoperiod.R: Idem * inst/tinytest/test_nanotime.R: Idem 2020-08-08 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version, small edit * src/interval.cpp: Add some tests for non-zero length vectors * inst/tinytest/test_nanotime.R: Skip one test upsetting SAN * tests/tinytest.R: Default back to serial tests * src/strnlen.cpp: Added strnlen_ to help Solaris * inst/include/nanotime/utilities.hpp: Declare it * src/interval.cpp: Use it * src/nanotime.cpp: Idem 2020-08-07 Leonardo Silvestri * src/period.cpp: Add extra braces to appease macOS compiler * src/inst/include/nanotime/globals.hpp: Use chrono duration; remove ambiguous time_point and seconds declarations 2020-08-05 Dirk Eddelbuettel * DESCRIPTION (Date, Version): Release 0.3.0 2020-08-02 Leonardo Silvestri * src/interval.cpp: Use non-throwing RcppCCTZ function * src/nanotime.cpp: Idem * src/period.cpp: Idem * inst/include/nanotime/globals.hpp: More (u)int64_t * R/nanoival.R: Refine error message check * R/nanotime.R: Idem 2020-07-29 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version 2020-07-29 Leonardo Silvestri * src/Makevars.win: Add to set explicit '-mno-ms-bitfields' flag required for bitfield operations on Windows 2020-07-21 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * inst/NEWS.Rd: Additional entries added 2020-07-20 Leonardo Silvestri * vignettes/nanotime/rmd/nanotime-intro.Rmd: Additional edits 2020-07-19 Dirk Eddelbuettel * vignettes/nanotime/rmd/nanotime-intro.Rmd: Additional edits * vignettes/nanotime/rmd/nanotime-intro.bib: Updated bibliography 2020-07-11 Leonardo Silvestri * DESCRIPTION (Version, Date): Roll minor version * inst/include/nanotime/duration.hpp: move headers to 'nanotime' and put 'interval' and 'period' in a namespace * directory inst/include/nanotime/globals.hpp: Idem * inst/include/nanotime/interval.hpp: Idem * inst/include/nanotime/period.hpp: Idem * inst/include/nanotime/pseudovector.hpp: Idem * inst/include/nanotime/utilities.hpp: Idem * src/duration.cpp: Idem * src/interval.cpp: Idem * src/nanotime.cpp: Idem * src/period.cpp: Idem * src/rounding.cpp: Idem * src/Makevars: Idem * inst/include/nanotime/pseudovector.hpp: let 'pseudovector' return a different type than the input which gives more flexibility 2020-05-17 Dirk Eddelbuettel * vignettes/nanotime-intro.pdf: Copy of prebuilt vignette from rmd/ * vignettes/nanotime-introduction.Rnw: Sweave shell for prebuilt vignette * .travis.yml: Switch to bionic, and testing via R 4.0.0 2020-05-16 Leonardo Silvestri * DESCRIPTION (Version, Date): Roll minor version * R/nanoduration.R: correct NA and negative subsetting; implement 'rep' * R/nanoival.R: Idem * R/nanoperiod.R: Idem * R/nanotime.R: Idem * inst/include/globals.hpp: correct NA and negative subsetting * inst/include/interval.hpp: Idem * inst/include/utilities.hpp: Idem * inst/tinytest/test_nanoduration.R: Idem * inst/tinytest/test_nanoival.R: Idem * inst/tinytest/test_nanoperiod.R: Idem * inst/tinytest/test_nanotime.R: Idem * src/duration.cpp: Idem * src/interval.cpp: Idem * src/nanotime.cpp: Idem * src/period.cpp: Idem * man/rep-nanoduration-method.Rd: document 'rep' * man/rep-nanoival-method.Rd: document 'rep' * man/rep-nanoperiod-method.Rd: document 'rep' * man/rep-nanotime-method.Rd: document 'rep' 2020-05-10 Leonardo Silvestri * DESCRIPTION (Version, Date): Roll minor version * R/nanoival.R: check param types before invoking C functions; use 'na.rm' in 'is.unsorted' * inst/tinytest/test_nanoival.R: Idem * R/nanoperiod.R: check param types before invoking C functions * R/nanotime.R: Idem * inst/tinytest/test_nanoperiod.R: Idem * src/RcppExports.cpp: Idem * src/interval.cpp: Idem * man/nanotime.Rd: document 'tz' param behaviour in constructor 2020-04-25 Leonardo Silvestri * DESCRIPTION (Version, Date): Roll minor version * NAMESPACE: Added rounding functions 'nano_floor' and 'nano_ceiling' * R/RcppExports.R: Idem * R/nanoduration.R: Idem * R/nanoperiod.R: Idem * R/nanotime.R: Idem * inst/include/period.hpp: Idem * inst/tinytest/test_nanoduration.R: Idem * inst/tinytest/test_nanoperiod.R: Idem * man/rounding.Rd: Idem * src/RcppExports.cpp: Idem * src/rounding.cpp: Idem * vignettes/nanotime-introduction.Rnw: Wrapper as in anytime * vignettes/nanotime-intro.pdf: Pre-made pdf * vignettes/nanotime/rmd/nanotime-intro.Rmd: New draft vignette * vignettes/nanotime/rmd/nanotime-intro.bib: New bibliography 2020-04-09 Dirk Eddelbuettel * README.md: Add 'last commit' badge 2020-03-31 Leonardo Silvestri * DESCRIPTION (Version, Date): Roll minor version * R/nanoduration.R: Added all.equal * R/nanoival.R: Idem * R/nanoperiod.R: Idem * R/nanotime.R: Idem * inst/tinytest/test_nanoduration.R: Idem * inst/tinytest/test_nanoival.R: Idem * inst/tinytest/test_nanoperiod.R: Idem * inst/tinytest/test_nanotime.R: Idem * man/all.equal-nanoperiod-ANY-method.Rd: deleted * man/all.equal.nanotime.Rd: Idem * man/all.equal.nanoduration.Rd: Idem * man/all.equal.nanoival.Rd: Idem * man/all.equal.nanoperiod.Rd: Idem 2020-03-29 Leonardo Silvestri * DESCRIPTION: fixed 0-length-vector ops * R/RcppExports.R: Idem * R/nanoperiod.R: Idem * inst/include/utilities.hpp: Idem * inst/tinytest/test_nanoival.R: Idem * inst/tinytest/test_nanoperiod.R: Idem * inst/tinytest/test_nanotime.R: Idem * src/RcppExports.cpp: Idem * src/interval.cpp: Idem * src/nanotime.cpp: Idem * src/period.cpp: Idem 2020-03-27 Leonardo Silvestri * DESCRIPTION: added %in%.nanotime * NAMESPACE: Idem * R/RcppExports.R: Idem * R/nanoival.R: Idem * R/nanoperiod.R: Idem * inst/tinytest/test_nanoival.R: Idem * man/nanoduration.Rd: Idem * man/nanoival.Rd: Idem * man/nanoperiod.Rd: Idem * man/nanotime.Rd: Idem * man/set_operations.Rd: Idem * src/RcppExports.cpp: Idem * src/interval.cpp: Idem 2020-03-25 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * DESCRIPTION (LinkingTo): Add RcppDate providing date.h * src/nanotime.cpp (nanotime_wday_impl): Update one accessor for newer version of date.h * inst/include/date.h: Deleted as no longer needed * .travis.yml (install): Install RcppDate * inst/include/globals.hpp: Add a single #nocov 2020-03-23 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version 2020-03-22 Leonardo Silvestri * README.md: updated information 2020-03-21 Leonardo Silvestri * inst/include/globals.hpp: parse format ending with 'Z' for data.table compatibility * src/period.cpp: fix vectorized 'plus'/'minus' ops for 'nanoperiod' * inst/tinytest/test_nanoperiod.R: Idem 2020-03-20 Dirk Eddelbuettel * src/duration.cpp: Slightly more idiomatic Rcpp * src/period.cpp: Idem * R/nanoduration.R: Idem * R/nanoperiod.R: Idem * R/nanotime.R: Idem 2020-03-19 Dirk Eddelbuettel * src/interval.cpp: Slightly more idiomatic Rcpp * R/nanoival.R: Idem 2020-03-18 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * DESCRIPTION (Imports): Updated versioned Depends: on RcppCCTZ * NAMESPACE: Turn on registration * src/nanotime.cpp: Slightly more idiomatic Rcpp * R/nanotime.R: Idem 2020-03-15 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * src/duration.cpp: Small fix to cast to plain old type * src/interval.cpp: Idem * src/nanotime.cpp: Idem * src/Makevars (PKG_CXXFLAGS): Minor edits * cleanup: Added minor helper 2020-03-14 Leonardo Silvestri [ The following reflects a fairly substantial set of changes made over a longer period and are just summarized here ] * DESCRIPTION: Add versioned Depends on RcppCCTZ * NAMESPACE: Load dynamic library * R/duration.R: Add new nanoival, duration, and period * R/nanoival.R: Idem * R/nanotime.R: Idem * R/period.R: Idem * inst/include/date.h: Idem * inst/include/duration.hpp: Idem * inst/include/globals.hpp: Idem * inst/include/interval.hpp: Idem * inst/include/period.hpp: Idem * inst/include/pseudovector.hpp: Idem * inst/include/utilities.hpp: Idem * inst/tinytest/test_data.frame.R: Idem * inst/tinytest/test_duration.R: Idem * inst/tinytest/test_nanoival.R: Idem * inst/tinytest/test_nanotime.R: Idem * inst/tinytest/test_ops.R: Idem * inst/tinytest/test_period.R: Idem * man/duration.Rd: Idem * man/nanoival.Rd: Idem * man/nanotime.Rd: Idem * man/period.Rd: Idem * src/Makevars: Idem * src/duration.cpp: Idem * src/interval.cpp: Idem * src/nanotime.cpp: Idem * src/period.cpp: Idem * .travis.yml: For now load development version of RcppCCTZ from GitHub 2019-11-21 Dirk Eddelbuettel * DESCRIPTION (Version, Date): New minor version * inst/tinytest/test_*.R: Moved from ../unitTest, changed to tinytest * tests/tinytest.R: Add test runner for tinytest * DESCRIPTION (Suggests): Add tinytest, remove RUnit * .travis.yml (install): Add r-cran-tinytest, remove r-cran-runit * tests/runTests.R: Removed RUnit test runner 2019-11-20 Dirk Eddelbuettel * DESCRIPTION (Version, Date): New minor version * R/nanotime.R (as.integer64.nanotime): Adding 'Compare' ops for character and nanotime * inst/unitTests/test_ops.R: Adjust one existing test, and add six new ones for character and nanotime comparisons * man/nanotime.Rd: Document new comparison operators 2019-05-25 Dirk Eddelbuettel * DESCRIPTION (Date, Version): Release 0.2.4 2019-05-23 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * R/nanotime.R (as.integer64.nanotime): Define [[ accessor * inst/unitTests/test_nanotime.R (test_square_bracket): Add test * man/nanotime.Rd: Add alias 2019-04-03 Dirk Eddelbuettel * README.md: Add dependencies badge 2018-09-30 Dirk Eddelbuettel * DESCRIPTION (Date, Version): Release 0.2.3 2018-09-02 Dirk Eddelbuettel * .travis.yml: Switch Travis CI to R 3.5 repo 2018-08-31 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * inst/unitTests/test_nanotime.R: Skip some tests on Solaris * inst/unitTests/test_zoo.R: Idem 2018-07-18 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.2.2 * inst/unitTests/test_xts.R: Continue to disable xts tests even after 0.11.0 release 2018-07-01 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.2.1 2018-06-30 Dirk Eddelbuettel * R/nanotime.R (format.nanotime): Protect from empty argument 2018-06-23 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * R/nanotime.R: Two extras casts to integer64 in constructors 2018-04-19 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version 2018-04-18 Leonardo Silvestri * R/nanotime.R (Compare): Added attribute-preserving comparison * man/nanotime.Rd: Corresponding documentation 2017-06-22 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.2.0 2017-06-21 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * DESCRIPTION (Imports): Require RcppCCTZ (>= 0.2.3) * inst/unitTests/test_nanotime.R: No longer condition out Windows * inst/unitTests/test_nanotime.R: Ditto * inst/unitTests/test_xts.R: Ditto * .travis.yml (group): Added as required by Travis CI 2017-06-16 Dirk Eddelbuettel * R/nanotime.R (nanotime.matrix): Adding '#nocov' tags 2017-06-15 Dirk Eddelbuettel * DESCRIPTION (Version, Date): New minor version * tests/runTests.R: Rewritten test runner * inst/unitTests/test_zoo.R (test_zoo): Condition on zoo present, and test not running under Windows * inst/unitTests/test_xts.R (.setUp): Condition on a 'future' xts version present as we really nedd xts to be nanotime aware for these tests * inst/unitTests/test_nanotime.R: Condition a number of tests on not running under Windows * DESCRIPTION (Suggests): Added 'xts' * .travis.yml (install): Ditto 2017-06-14 Leonardo Silvestri * R/nanotime.R: Error on ops not meaningful for type, also fix handling of NA, NAN, Inf, -Inf * man/nanotime.Rd: Corresponding documentation * inst/unitTests/test_nanotime.R: corresponding test 2017-06-05 Leonardo Silvestri * R/nanotime.R: Correct summary() by defining 'names<-'; fix 'c' * man/nanotime.Rd: Corresponding documentation * inst/unitTests/test_nanotime.R: corresponding test 2017-06-03 Leonardo Silvestri * R/nanotime.R: Prevent print from printing more than options()$max.print 2017-06-02 Leonardo Silvestri * R/nanotime.R: Ensure names are kept for nanotime vectors * inst/unitTests/test_nanotime.R: corresponding test 2017-05-02 Leonardo Silvestri * R/nanotime.R: Ensure 'tz=""' is treated as missing 2017-04-04 Leonardo Silvestri * R/nanotime.R: Remove spurious debug output 2017-03-29 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * man/nanotime.Rd: Minor update * nanotime.Rproj: Use devtools::document to work around a roxygen2 bug with S4 and setOldClass 2017-03-29 Leonardo Silvestri [ The following is summary of changes made over several weeks ] * DESCRIPTION: Convert to S4 class * NAMESPACE: Idem * R/nanotime.R: Idem * inst/unitTests/test_data.frame.R: Idem * inst/unitTests/test_nanotime.R: Idem * inst/unitTests/test_ops.R: Idem * inst/unitTests/test_xts.R: Idem * inst/unitTests/test_zoo.R: Idem * man/nanotime-class.Rd: Idem * man/nanotime-package.Rd: Idem * man/nanotime.Rd: Idem * tests/runTests.R: Idem * tests/simpleTests.R: Idem 2017-03-27 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.1.2 2017-02-08 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version and date * NAMESPACE: Also (re-)export as.integer64 * R/nanotime.R: Added roxygen2 snippet for as.integer64 * man/nanotime.Rd: Documentation 2017-02-04 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.1.1 2017-01-31 Dirk Eddelbuettel * R/nanotime.R: One more updated format string 2017-01-30 Dirk Eddelbuettel * R/nanotime.R (format.nanotime): Safer transformation to double (index2char.nanotime): Idem 2017-01-29 Dirk Eddelbuettel * R/nanotime.R: Additional documentation section on default output format string * .travis.yml (before_install): Use https for curl fetch 2017-01-25 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version and date * R/nanotime.R (nanotime.character): Display of nine dec digits (format.nanotime): Idem (print.nanotime): Dispatch to format.nanotime (thanks, Matt!) (as.integer64.nanotime): New converter to integer64 (Ops.nanotime): Explicit definition with some casts * NAMESPACE: Corresponding exports * man/nanotime.Rd: Corresponding documentation 2017-01-10 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.1.0 2017-01-09 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * DESCRIPTION (SystemRequirements, OS_type): Remove constraint on Unix as RcppCCTZ is now available on Windows too * demo/nanosecondDelayExample.R: Add missing library() calls; added save and reload example * README.md: Small edit showing save and reload 2016-12-22 Dirk Eddelbuettel * README.md: Updated to reflect CRAN status 2016-12-18 Dirk Eddelbuettel * demo/00Index: New file, demo now in package * demo/nanosecondDelayExample.R: Renamed demo 2016-12-17 Dirk Eddelbuettel * R/nanotime.R (as.data.frame.nanotime): Documented (nanotime.character): Support tz and fmt options (format.nanotime): Idem (index2char.nanotime): Idem (as.POSIXct.nanotime): Idem (as.POSIXlt.nanotime): Idem * man/nanotime.Rd: Idem * tests/data.frame.R: Added simple data.{frame,table} test * tests/simpleTests.R: Added simple format tests * demo/nanotimeEx.R: Extended somewhat * DESCRIPTION (Suggests): Added data.table * .travis.yml: Added r-cran-data.table 2016-12-16 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Rolled minor version * R/nanotime.R (as.data.frame.nanotime): New method (format.nanotime): Support additional arguments * man/nanotime.Rd: Updated for new method * NAMESPACE: Idem 2016-12-15 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Release 0.0.1 * R/nanotime.R (as.POSIXct.nanotime,as.POSIXlt.nanotime) (as.Date.nanotime): New converters (format.nanotime): Add 'justify' argument * man/nanotime.Rd: Document new and updated methods * NAMESPACE: Registered new converters * tests/simpleTests.R: Additional calls to new functions * inst/NEWS.Rd: Added * DESCRIPTION (SystemRequirements): State RcppCCTZ dependency 2016-12-11 Dirk Eddelbuettel * R/nanotime.R (index2char.nanotime): Added to have zoo() objects print a nanotime index correctly (nanotime.default): Switch class order with integer64 last (print.nanotime): Minor adjustment (format.nanotime): Added (showNanotime): Removed (format.nanotime): Support global option for format * NAMESPACE: Register S3 methods index2char.nanotime, format.nanotime; import two functions from RcppCCTZ (which are now exported) * DESCRIPTION: Now Imports: rather than Suggests: zoo * tests/zooTests.R: Small changes * .travis.yml: Added * .codecov.yml: Ditto * .Rbuildignore: Adjusted accordingly * tests/simpleTests.R: Two more conversions from integer and numeric 2016-12-10 Dirk Eddelbuettel * tests/zooTests.R: Simple tests for vectorised time operation * R/nanotime.R (print.nanotime): Do not default to character formating here, rather farm out to helper showNanotime (showNanotime): Simple pretty printer * tests/simpleTests.R: Added calls to snowNanotime() 2016-12-09 Dirk Eddelbuettel * DESCRIPTION (Version): Very initial pre-release 0.0.0 nanotime/README.md0000644000176200001440000002106614160634652013357 0ustar liggesusers## nanotime: Nanosecond-Resolution Time Objects for R [![CI](https://github.com/eddelbuettel/nanotime/workflows/ci/badge.svg)](https://github.com/eddelbuettel/nanotime/actions?query=workflow%3Aci) [![License](https://eddelbuettel.github.io/badges/GPL2+.svg)](https://www.gnu.org/licenses/gpl-2.0.html) [![CRAN](https://www.r-pkg.org/badges/version/nanotime)](https://cran.r-project.org/package=nanotime) [![Dependencies](https://tinyverse.netlify.com/badge/nanotime)](https://cran.r-project.org/package=nanotime) [![Downloads](https://cranlogs.r-pkg.org/badges/nanotime?color=brightgreen)](https://www.r-pkg.org/pkg/nanotime) [![Code Coverage](https://codecov.io/gh/eddelbuettel/nanotime/graph/badge.svg)](https://app.codecov.io/gh/eddelbuettel/nanotime) [![Last Commit](https://img.shields.io/github/last-commit/eddelbuettel/nanotime)](https://github.com/eddelbuettel/nanotime) [![Documentation](https://img.shields.io/badge/documentation-is_here-blue)](https://eddelbuettel.github.io/nanotime/) ### Motivation R has excellent tools for dates and times. The `Date` and `POSIXct` classes (as well as the 'wide' representation in `POSIXlt`) are versatile, and a lot of useful tooling has been built around them. However, `POSIXct` is implemented as a `double` with fractional seconds since the epoch. Given the 53 bits accuracy, it leaves just a bit less than _microsecond_ resolution. Furthermore, using floating-point arithmetic for an integer concept opens the door to painful issues of error accumulation. More and more performance measurements, latency statistics, etc., are now measured more finely, and we need _nanosecond_ resolution for which commonly an `integer64` is used to represent nanoseconds since the epoch. And while R does not have a _native_ type for this, the [bit64](https://cran.r-project.org/package=bit64) package by [Jens Oehlschlägel](https://github.com/joehl) offers a performant one implemented as a lightweight S3 class. So this package uses the `integer64` class, along with multiple helper functions for parsing and formatting at nano-second resolution from the [RcppCCTZ](https://dirk.eddelbuettel.com/code/rcpp.cctz.html) package which wraps the [CCTZ library](https://github.com/google/cctz) from Google. CCTZ is a modern C++11 library extending the (C++11-native) `chrono` type. In addition to the point-in-time type `nanotime`, this package also provides an interval type `nanoival` which may have open or closed start/end, a period type `nanoperiod` that is a human representation of time, such as day, month, etc., and a duration type `nanoduration`. These types are similar to what the [lubridate](https://github.com/tidyverse/lubridate) package proposes. Set and arithmetic operations on these types are available. All functionality is designed to correctly handle instances across different time zones. Because these temporal types are based on R built-in types, most functions have an efficient implementation and the types are suitable for use in `data.frame` and `data.table`. `nanotime` is also a better choice than the native `POSIXct` in most of the cases where fractional seconds are needed because it avoids floating point issues. ### Documentation Package documentation, help pages, a vignette, and more is available [here](https://eddelbuettel.github.io/nanotime/). ### Demo See the included demo script [nanosecondDelayExample.R](https://github.com/eddelbuettel/nanotime/blob/master/demo/nanosecondDelayExample.R) for a (completely simulated and hence made-up) study of network latency measured in nanoseconds resulting in the figure below ![](https://eddelbuettel.github.io/nanotime/assets/nanotimeDelayDemo.png) ### Examples #### Simple Parsing and Arithmetic ```r R> x <- as.nanotime("1970-01-01T00:00:00.000000001+00:00") R> x [1] "1970-01-01T00:00:00.000000001+00:00" R> x + 1e9 [1] "1970-01-01T00:00:01.000000001+00:00" R> as.nanotime("2020-03-21 Europe/London") [1] 2020-03-21T00:00:00+00:00 ``` #### Vectorised ```r R> options("width"=60) R> v <- nanotime(Sys.time()) + 1:5 R> v [1] 2020-03-22T03:09:20.732122001+00:00 [2] 2020-03-22T03:09:20.732122002+00:00 [3] 2020-03-22T03:09:20.732122003+00:00 [4] 2020-03-22T03:09:20.732122004+00:00 [5] 2020-03-22T03:09:20.732122005+00:00 R> ``` #### Use with `zoo` ```r R> library(zoo) R> z <- zoo(cbind(A=1:5, B=5:1), v) R> options(nanotimeFormat="%H:%M:%E*S") ## override default format R> z R> options(nanotimeFormat=NULL) ## go back to default format R> z ``` #### Use with data.table ```r R> library(data.table) R> dt <- data.table(v, cbind(A=1:5, B=5:1)) R> fwrite(dt, file="datatableTest.csv") # write out R> dtcheck <- fread("datatableTest.csv") # read back R> dtcheck R> dtcheck[, v:=nanotime(v)] # read as a string, need to re-class as nanotime R> fread("../datatableTest.csv", colClasses=c("nanotime", "integer", "integer")) ``` #### Use with data.frame This requires version 0.0.2 or later. ```r R> data.frame(cbind(A=1:5, B=5:1), v=v) ``` #### Intervals ```r R> ival <- as.nanoival("+2009-01-01 13:12:00 America/New_York -> 2009-02-01 15:11:03 America/New_York-") R> ival [1] +2009-01-01T18:12:00+00:00 -> 2009-02-01T20:11:03+00:00- R> start <- nanotime("2009-01-01 13:12:00 America/New_York") R> end <- nanotime("2009-02-01 15:11:00 America/New_York") R> nanoival(start, end) # by default sopen=F,eopen=T [1] +2009-01-01T18:12:00+00:00 -> 2009-02-01T20:11:00+00:00- R> nanoival(start, end, sopen=FALSE, eopen=TRUE) [1] +2009-01-01T18:12:00+00:00 -> 2009-02-01T20:11:00+00:00- R> intersect(as.nanoival("+2019-03-01 UTC -> 2020-03-01 UTC-"), as.nanoival("+2020-01-01 UTC -> 2020-06-01 UTC-")) [1] +2020-01-01T00:00:00+00:00 -> 2020-03-01T00:00:00+00:00- R> union(as.nanoival("+2019-03-01 UTC -> 2020-03-01 UTC-"), as.nanoival("+2020-01-01 UTC -> 2020-06-01 UTC-")) [1] +2019-03-01T00:00:00+00:00 -> 2020-06-01T00:00:00+00:00- R> setdiff(as.nanoival("+2019-03-01 UTC -> 2020-03-01 UTC-"), as.nanoival("+2020-01-01 UTC -> 2020-06-01 UTC-")) [1] +2019-03-01T00:00:00+00:00 -> 2020-01-01T00:00:00+00:00- ``` #### Periods ```r R> as.nanoperiod("1y1m1w1d/01:01:01.000_000_001") [1] 13m8d/01:01:01.000_000_001 R> nanoperiod(months=13, days=-1, duration="01:00:00") [1] 13m-1d/01:00:00 R> ones <- as.nanoperiod("1y1m1w1d/01:01:01.000_000_001") R> nanoperiod.month(ones); nanoperiod.day(ones); nanoperiod.nanoduration(ones) [1] 13 [1] 8 [1] 01:01:01.000_000_001 R> plus(v, as.nanoperiod("1y1m"), tz="UTC") [1] 2021-04-22T03:09:20.732122001+00:00 [2] 2021-04-22T03:09:20.732122002+00:00 [3] 2021-04-22T03:09:20.732122003+00:00 [4] 2021-04-22T03:09:20.732122004+00:00 [5] 2021-04-22T03:09:20.732122005+00:00 ``` #### Durations ```{r} R> nanoduration(hours=1, minutes=1, seconds=1, nanoseconds=1) R> as.nanoduration("00:00:01") R> as.nanoduration("-00:00:01") R> as.nanoduration("100:00:00") R> as.nanoduration("00:00:00.000_000_001") ``` #### Sequences ``` {r} R> from <- as.nanotime("2018-09-14T12:44:00+00:00") R> seq(from, by=as.nanoperiod("1y"), length.out=4, tz="Europe/London") [1] 2018-09-14T12:44:00+00:00 [2] 2019-09-14T12:44:00+00:00 [3] 2020-09-14T12:44:00+00:00 [4] 2021-09-14T12:44:00+00:00 ``` ### Technical Details The [bit64](https://cran.r-project.org/package=bit64) package (by [Jens Oehlschlägel](https://github.com/joehl)) supplies the `integer64` type used to store the nanosecond resolution time as (positive or negative) offsets to the epoch of January 1, 1970. The [RcppCCTZ](https://dirk.eddelbuettel.com/code/rcpp.cctz.html) package supplies the formatting and parsing routines based on the (modern C++) library [CCTZ](https://github.com/google/cctz) from Google, when the parsing cannot be done using a fast built-in parser. `integer64` is also used for the type `nanoduration`, whereas `nanoival` and `nanoperiod` are stored in a `complex`, i.e. over 128 bits. ### Status The package is by now fairly mature, has been rewritten once (to go from S3 to S4) and has recently received a sizeable feature extension. There may still be changes, though there should generally never be breaking ones. The package also has an extensive test suite, and very good code coverage. See the [issue tickets](https://github.com/eddelbuettel/nanotime/issues) for an up to date list of potentially desirable, possibly planned, or at least discussed items. ### Installation The package is on [CRAN](https://cran.r-project.org) and can be installed via a standard ```r install.packages("nanotime") ``` whereas in order to install development versions a ```r remotes::install_github("eddelbuettel/nanotime") # dev version ``` should suffice. ### Authors Dirk Eddelbuettel and Leonardo Silvestri ### License GPL (>= 2) nanotime/man/0000755000176200001440000000000014323545236012646 5ustar liggesusersnanotime/man/nanoperiod.Rd0000644000176200001440000002073714131075437015302 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoperiod.R \docType{class} \name{nanoperiod-class} \alias{nanoperiod-class} \alias{nanoperiod} \alias{Compare,ANY,nanoperiod-method} \alias{Compare,nanoperiod,ANY-method} \alias{-,ANY,nanoperiod-method} \alias{-,nanoperiod,nanotime-method} \alias{-,nanotime,nanoperiod-method} \alias{/,ANY,nanoperiod-method} \alias{/,nanoperiod,ANY-method} \alias{Complex,nanoperiod-method} \alias{Math,nanoperiod-method} \alias{Math2,nanoperiod-method} \alias{Summary,nanoperiod-method} \alias{minus,nanoperiod,nanoival,character-method} \alias{as.nanoperiod,character-method} \alias{as.nanoperiod} \alias{as.nanoperiod,integer64-method} \alias{as.nanoperiod,numeric-method} \alias{as.nanoperiod,integer-method} \alias{as.nanoperiod,nanoduration-method} \alias{as.nanoperiod,NULL-method} \alias{as.nanoperiod,missing-method} \alias{show,nanoperiod-method} \alias{print,nanoperiod-method} \alias{format.nanoperiod} \alias{as.character,nanoperiod-method} \alias{is.na,nanoperiod-method} \alias{is.na<-,nanoperiod-method} \alias{[[,nanoperiod-method} \alias{[,nanoperiod,numeric-method} \alias{[,nanoperiod,logical-method} \alias{[,nanoperiod,character-method} \alias{[,nanoperiod,ANY-method} \alias{[<-,nanoperiod,ANY,ANY,ANY-method} \alias{c.nanoperiod} \alias{names,nanoperiod-method} \alias{names<-,nanoperiod-method} \alias{-,nanoperiod,ANY-method} \alias{-,nanoperiod,nanoperiod-method} \alias{-,nanoperiod,nanoduration-method} \alias{-,nanoperiod,integer64-method} \alias{-,nanoperiod,numeric-method} \alias{-,nanoduration,nanoperiod-method} \alias{-,integer64,nanoperiod-method} \alias{-,numeric,nanoperiod-method} \alias{+,nanoperiod,ANY-method} \alias{+,ANY,nanoperiod-method} \alias{+,nanoperiod,nanoperiod-method} \alias{+,nanoperiod,nanoduration-method} \alias{+,nanoperiod,integer64-method} \alias{+,nanoperiod,nanotime-method} \alias{+,nanoival,nanoperiod-method} \alias{+,nanoperiod,nanoival-method} \alias{+,nanotime,nanoperiod-method} \alias{+,nanoperiod,numeric-method} \alias{+,nanoduration,nanoperiod-method} \alias{+,integer64,nanoperiod-method} \alias{+,numeric,nanoperiod-method} \alias{*,nanoperiod,integer64-method} \alias{*,nanoperiod,ANY-method} \alias{*,ANY,nanoperiod-method} \alias{*,nanoperiod,numeric-method} \alias{*,integer64,nanoperiod-method} \alias{*,numeric,nanoperiod-method} \alias{/,nanoperiod,integer64-method} \alias{/,nanoperiod,numeric-method} \alias{==,nanoperiod,nanoperiod-method} \alias{!=,nanoperiod,nanoperiod-method} \alias{plus,nanotime,nanoperiod,character-method} \alias{plus} \alias{plus,nanoperiod,nanotime,character-method} \alias{minus,nanotime,nanoperiod,character-method} \alias{minus} \alias{minus,nanoperiod,nanotime,character-method} \alias{plus,nanoival,nanoperiod,character-method} \alias{plus,nanoperiod,nanoival,character-method} \alias{minus,nanoival,nanoperiod,character-method} \alias{NA_nanoperiod_} \title{Period type with nanosecond precision} \format{ An object of class \code{nanoperiod} of length 1. } \usage{ nanoperiod(months = 0, days = 0, duration = as.nanoduration(0)) \S4method{as.nanoperiod}{character}(x) \S4method{as.nanoperiod}{integer64}(x) \S4method{as.nanoperiod}{numeric}(x) \S4method{as.nanoperiod}{integer}(x) \S4method{as.nanoperiod}{nanoduration}(x) \S4method{as.nanoperiod}{`NULL`}(x) \S4method{as.nanoperiod}{missing}(x) \S4method{show}{nanoperiod}(object) \S4method{print}{nanoperiod}(x, quote = FALSE, ...) \method{format}{nanoperiod}(x, ...) \S4method{as.character}{nanoperiod}(x) \S4method{is.na}{nanoperiod}(x) \S4method{is.na}{nanoperiod}(x) <- value \S4method{[[}{nanoperiod}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoperiod,numeric}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoperiod,logical}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoperiod,character}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoperiod,ANY}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoperiod,ANY,ANY,ANY}(x, i, j, ...) <- value \method{c}{nanoperiod}(...) \S4method{names}{nanoperiod}(x) \S4method{names}{nanoperiod}(x) <- value \S4method{-}{nanoperiod,ANY}(e1, e2) \S4method{-}{nanoperiod,nanoperiod}(e1, e2) \S4method{-}{nanoperiod,nanoduration}(e1, e2) \S4method{-}{nanoperiod,integer64}(e1, e2) \S4method{-}{nanoperiod,numeric}(e1, e2) \S4method{-}{nanoduration,nanoperiod}(e1, e2) \S4method{-}{integer64,nanoperiod}(e1, e2) \S4method{-}{numeric,nanoperiod}(e1, e2) \S4method{+}{nanoperiod,ANY}(e1, e2) \S4method{+}{nanoperiod,nanoperiod}(e1, e2) \S4method{+}{nanoperiod,nanoduration}(e1, e2) \S4method{+}{nanoperiod,integer64}(e1, e2) \S4method{+}{nanoperiod,nanotime}(e1, e2) \S4method{+}{nanoival,nanoperiod}(e1, e2) \S4method{+}{nanoperiod,nanoival}(e1, e2) \S4method{+}{nanotime,nanoperiod}(e1, e2) \S4method{+}{nanoperiod,numeric}(e1, e2) \S4method{+}{nanoduration,nanoperiod}(e1, e2) \S4method{+}{integer64,nanoperiod}(e1, e2) \S4method{+}{numeric,nanoperiod}(e1, e2) \S4method{*}{nanoperiod,integer64}(e1, e2) \S4method{*}{nanoperiod,numeric}(e1, e2) \S4method{*}{integer64,nanoperiod}(e1, e2) \S4method{*}{numeric,nanoperiod}(e1, e2) \S4method{/}{nanoperiod,integer64}(e1, e2) \S4method{/}{nanoperiod,numeric}(e1, e2) \S4method{==}{nanoperiod,nanoperiod}(e1, e2) \S4method{!=}{nanoperiod,nanoperiod}(e1, e2) \S4method{plus}{nanotime,nanoperiod,character}(e1, e2, tz) \S4method{plus}{nanoperiod,nanotime,character}(e1, e2, tz) \S4method{minus}{nanotime,nanoperiod,character}(e1, e2, tz) \S4method{minus}{nanoperiod,nanotime,character}(e1, e2, tz) \S4method{plus}{nanoival,nanoperiod,character}(e1, e2, tz) \S4method{plus}{nanoperiod,nanoival,character}(e1, e2, tz) \S4method{minus}{nanoival,nanoperiod,character}(e1, e2, tz) NA_nanoperiod_ } \arguments{ \item{months}{Used in the constructor to indicate the number of months of the \code{nanoperiod}} \item{days}{Used in the constructor to indicate the number of days of the \code{nanoperiod}} \item{duration}{Used in the constructor to indicate the duration component of the \code{nanoperiod}} \item{x, value}{An object of class \code{nanoperiod}} \item{object}{argument for method \code{show}} \item{quote}{indicates if the output of \code{print} should be quoted} \item{...}{further arguments} \item{i}{index specifying elements to extract or replace.} \item{j}{Required for \code{[} signature but ignored here} \item{drop}{Required for \code{[} signature but ignored here} \item{e1}{Operand of class \code{nanoperiod}} \item{e2}{Operand of class \code{nanoperiod}} \item{tz}{\code{character} indicating a timezone} } \description{ \code{nanoperiod} is a length of time type (implemented as an S4 class) with nanosecond precision. It differs from \code{nanoduration} because it is capable of representing calendar months and days. It can thus represent years (12 months) and weeks (7 days). A period is a somewhat abstract representation of time: it is only when anchored to a point in time and in a specific time zone that it is possible to convert it to a specific duration. This means that many of the operations involving periods need the additional argument \code{tz}. } \section{Constructors}{ The true constructor is } \section{Output Format}{ A \code{nanoperiod} is displayed as months, days, and \code{nanoduration} like this: \code{10m2d/10:12:34.123_453_000}. } \section{Details}{ Adding or subtracting \code{nanoperiod} and \code{nanotime} require a timezone as third argument. For this reason it is not possible to use the binary operator `code{+}`. Instead the functions `\code{plus}` and `\code{minus}` are defined. These functions attempt to keep the same offset within a day in the specified timezone: this means for instance that adding a day when that day crosses a time zone adjustment such as a daylight saving time, results in a true time increment of less or more than 24 hours to preserve the offset. Preserving the offset works for increments that are smaller than a day too, provided the increment results in a datetime where the timezone adjustment is valid. When this is not the case, adding a `nanoperiod` behaves in the same way as adding a `nanoduration`. } \examples{ \dontrun{ p <- nanoperiod(months=12, days=7, duration="01:00:00") print(p) # when adding a \code{nanoperiod} to a \code{nanotime} or to a # \code{nanoival}, a time zone must be specified: y <- nanotime("1970-01-01T00:00:00+00:00") plus(y, p, tz="America/Chicago") } } \seealso{ \code{\link{nanotime}}, \code{\link{nanoduration}}, \code{\link{nanoival}}, \code{\link{nanoperiod.month,nanoperiod-method}} } \author{ Dirk Eddelbuettel Leonardo Silvestri } \keyword{datasets} nanotime/man/seq.nanotime.Rd0000644000176200001440000000244313714017251015533 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanotime.R \name{seq.nanotime} \alias{seq.nanotime} \alias{seq,nanotime-method} \title{Sequence Generation} \usage{ \method{seq}{nanotime}(from, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...) \S4method{seq}{nanotime}(from, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...) } \arguments{ \item{from, to}{the starting and (maximal) end values of the sequence} \item{by}{\code{nanoduration} or \code{nanoperiod} increment of the sequence; note that if the class is \code{nanoperiod} the additional argument \code{tz} must be speficied and is of \code{character} type indicating a timezone} \item{length.out}{integer indicating the desired length of the sequence} \item{along.with}{take the length from the length of this argument.} \item{...}{arguments passed to or from methods; the only interesting additional argument is \code{tz} where the \code{to} argument is of type \code{nanoperiod}} } \description{ Generate a sequence of \code{nanotime} } \examples{ \dontrun{ from <- as.nanotime("2018-01-14T12:44:00+00:00") to <- as.nanotime("2019-01-14T12:44:00+00:00") seq(from, to, by=as.nanoperiod("1m"), tz="America/New_York") seq(from, by=as.nanoperiod("1y"), length.out=4, tz="Europe/London") } } nanotime/man/nanoival.Rd0000644000176200001440000001772614131560240014746 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoival.R \docType{class} \name{nanoival-class} \alias{nanoival-class} \alias{nanoival} \alias{+,ANY,nanoival-method} \alias{+,nanoival,ANY-method} \alias{+,nanoival,nanoival-method} \alias{-,ANY,nanoival-method} \alias{-,nanoival,ANY-method} \alias{-,nanoival,nanoival-method} \alias{Arith,nanoival,ANY-method} \alias{Compare,nanoival,ANY-method} \alias{Complex,nanoival-method} \alias{Logic,ANY,nanoival-method} \alias{Logic,nanoival,ANY-method} \alias{Logic,nanoival,nanoival-method} \alias{Math2,nanoival-method} \alias{Math,nanoival-method} \alias{Summary,nanoival-method} \alias{nanoival.start,nanoival-method} \alias{nanoival.start} \alias{nanoival.end,nanoival-method} \alias{nanoival.end} \alias{nanoival.sopen,nanoival-method} \alias{nanoival.sopen} \alias{nanoival.eopen,nanoival-method} \alias{nanoival.eopen} \alias{format.nanoival} \alias{print,nanoival-method} \alias{show,nanoival-method} \alias{as.nanoival,character-method} \alias{as.nanoival} \alias{as.nanoival,NULL-method} \alias{as.nanoival,missing-method} \alias{is.na,nanoival-method} \alias{is.na<-,nanoival-method} \alias{<,nanoival,nanoival-method} \alias{<=,nanoival,nanoival-method} \alias{>,nanoival,nanoival-method} \alias{>=,nanoival,nanoival-method} \alias{==,nanoival,nanoival-method} \alias{!=,nanoival,nanoival-method} \alias{-,nanoival,integer64-method} \alias{-,nanoival,numeric-method} \alias{+,nanoival,integer64-method} \alias{+,nanoival,numeric-method} \alias{+,integer64,nanoival-method} \alias{+,numeric,nanoival-method} \alias{[[,nanoival-method} \alias{[,nanoival,logical-method} \alias{[,nanoival,numeric-method} \alias{[,nanoival,character-method} \alias{[,nanoival,ANY-method} \alias{[<-,nanoival,logical,ANY,nanoival-method} \alias{c.nanoival} \alias{t,nanoival-method} \alias{[,nanotime,nanoival-method} \alias{NA_nanoival_} \alias{as.character.nanoival} \title{Interval type with nanosecond precision} \format{ An object of class \code{nanoival} of length 1. } \usage{ nanoival(start, end, sopen = FALSE, eopen = TRUE) \S4method{nanoival.start}{nanoival}(x) \S4method{nanoival.end}{nanoival}(x) \S4method{nanoival.sopen}{nanoival}(x) \S4method{nanoival.eopen}{nanoival}(x) \method{format}{nanoival}(x, ...) \S4method{print}{nanoival}(x, quote = FALSE, ...) \S4method{show}{nanoival}(object) \S4method{as.nanoival}{character}(from, format = "", tz = "") \S4method{as.nanoival}{`NULL`}(from, format = "", tz = "") \S4method{as.nanoival}{missing}(from, format = "", tz = "") \S4method{is.na}{nanoival}(x) \S4method{is.na}{nanoival}(x) <- value \S4method{<}{nanoival,nanoival}(e1, e2) \S4method{<=}{nanoival,nanoival}(e1, e2) \S4method{>}{nanoival,nanoival}(e1, e2) \S4method{>=}{nanoival,nanoival}(e1, e2) \S4method{==}{nanoival,nanoival}(e1, e2) \S4method{!=}{nanoival,nanoival}(e1, e2) \S4method{-}{nanoival,integer64}(e1, e2) \S4method{-}{nanoival,numeric}(e1, e2) \S4method{+}{nanoival,integer64}(e1, e2) \S4method{+}{nanoival,numeric}(e1, e2) \S4method{+}{integer64,nanoival}(e1, e2) \S4method{+}{numeric,nanoival}(e1, e2) \S4method{[[}{nanoival}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoival,logical}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoival,numeric}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoival,character}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoival,ANY}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoival,logical,ANY,nanoival}(x, i, j, ...) <- value \method{c}{nanoival}(...) \S4method{t}{nanoival}(x) \S4method{[}{nanotime,nanoival}(x, i, j, ..., drop = TRUE) NA_nanoival_ \method{as.character}{nanoival}(x, ...) } \arguments{ \item{start}{\code{nanotime} start of interval} \item{end}{\code{nanotime} end of interval} \item{sopen}{logical indicating if the start of the interval is open} \item{eopen}{logical indicating if the end of the interval is open} \item{x, from}{a \code{nanoival} object} \item{...}{further arguments passed to or from methods.} \item{quote}{indicates if the output of \code{print} should be quoted} \item{object}{argument for method \code{show}} \item{format}{A character string. Can also be set via \code{options("nanotimeFormat")} and uses \sQuote{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez} as a default and fallback} \item{tz}{\code{character} indicating a timezone} \item{value}{argument for \code{nanoival-class}} \item{e1}{Operand of class \code{nanoival}} \item{e2}{Operand of class \code{nanoival}} \item{i}{index specifying elements to extract or replace.} \item{j}{Required for \code{[} signature but ignored here} \item{drop}{Required for \code{[} signature but ignored here} } \value{ A nanoival object } \description{ \code{nanoival} is a time interval type (an S4 class) with nanosecond precision. One of its purposes is to allow quick subsetting of a \code{nanotime} vector. \code{nanoival} is composed of a \code{nanotime} pair which defines the start and end of the time interval. Additionally, it has a pair of logical values which determine if the start and end of the time interval are open (true) or closed (false). } \details{ An interval object can be constructed with the constructor \code{nanoival} which takes as arguments two \code{nanotime} objects that define the start and the end of the interval, together with two \code{logical} arguments that define if the start and the end of the interval are open (true) or closed (false) (note that these objects can all be vector, and therefore the interval object is not necessarily scalar). Alternatively, an interval can be constructed with a \code{character}: the format follows that of \code{nanotime}; the start time is preceeded by either \code{-} or \code{+} indicating if the interval start is open (-) or closed (+); the start and end times are separated by an arrow \code{->}; the end is folloed by either \code{-} or \code{+} which have the same semantics as the start time. The most important set of methods defined for \code{interval} are set functions \code{intersect}, \code{union} and \code{setdiff}. Additionally, \code{interval} allows the subsetting into a \code{nanotime} vector. Note that subsetting is allowed only if the \code{nanotime} vector is sorted. Finally, accessors are provided to get the interval start (\code{start}), the end (\code{end}), the open/close status of the start (\code{sopen}) and the open/close status of the end (\code{eopen}). The former return a \code{nanotime} while the latter return a \code{logical}. } \section{Output Format}{ Formatting and character conversion for \code{nanoival} objects is identical to \code{nanotime} objects. The default format is ISO3339 compliant: \code{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez}. It specifies a standard ISO 8601 part for date and time --- as well as nine digits of precision for fractional seconds (down to nanoseconds) and on offset (typically zero as we default to UTC). It can be overriden by using \code{options()} with the key of \code{nanotimeFormat} and a suitable value. Similarly, \code{nanotimeTz} can be used to select a different timezone. } \examples{ \dontrun{ ## creating a \code{nanoival}, with the start time included ('+') and the end ## time excluded ('-') as.nanoival("+2012-03-01T21:21:00.000000001+00:00->2015-01-01T21:22:00.000000999+04:00-") ## a \code{nanoival} can also be created with a pair of \code{nanotime} objects, a start ## and an end, and optionally two logicals determining if the interval start(end) are open ## or closed; by default the start is closed and end is open: start <- nanotime("2012-03-01T21:21:00.000000001+00:00") end <- nanotime("2013-03-01T21:21:00.000000001+00:00") nanoival(start, end) ## a vector of 'nanotime' can be subsetted by a 'nanoival': one_second <- 1e9 a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) idx <- c(as.nanoival("-2012-12-12 12:12:10+00:00 -> 2012-12-12 12:12:14+00:00-"), as.nanoival("+2012-12-12 12:12:18+00:00 -> 2012-12-12 12:12:20+00:00+")) a[idx] } } \seealso{ \code{\link{intersect.idx}}, \code{\link{setdiff.idx}}, } \author{ Dirk Eddelbuettel Leonardo Silvestri } \keyword{datasets} nanotime/man/nanotime.Rd0000644000176200001440000002262114131560240014737 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanotime.R, R/nanoduration.R \docType{class} \name{nanotime-class} \alias{nanotime-class} \alias{nanotime} \alias{as.nanotime} \alias{nanotime,character-method} \alias{as.nanotime,character-method} \alias{nanotime.matrix} \alias{nanotime,POSIXct-method} \alias{as.nanotime,POSIXct-method} \alias{nanotime,POSIXlt-method} \alias{as.nanotime,POSIXlt-method} \alias{nanotime,Date-method} \alias{as.nanotime,Date-method} \alias{print,nanotime-method} \alias{show,nanotime-method} \alias{format.nanotime} \alias{index2char.nanotime} \alias{as.POSIXct.nanotime} \alias{as.POSIXlt.nanotime} \alias{as.Date.nanotime} \alias{as.data.frame.nanotime} \alias{as.integer64.nanotime} \alias{-,nanotime,character-method} \alias{-,nanotime,nanotime-method} \alias{-,nanotime,integer64-method} \alias{-,nanotime,numeric-method} \alias{-,ANY,nanotime-method} \alias{-,nanotime,ANY-method} \alias{+,nanotime,ANY-method} \alias{+,nanotime,integer64-method} \alias{+,nanotime,numeric-method} \alias{+,ANY,nanotime-method} \alias{+,integer64,nanotime-method} \alias{+,numeric,nanotime-method} \alias{+,nanotime,nanotime-method} \alias{Arith,nanotime,nanotime-method} \alias{Arith,nanotime,ANY-method} \alias{Arith,ANY,nanotime-method} \alias{Compare,nanotime,character-method} \alias{Compare,character,nanotime-method} \alias{Compare,nanotime,POSIXt-method} \alias{Compare,POSIXt,nanotime-method} \alias{Compare,nanotime,ANY-method} \alias{Logic,nanotime,ANY-method} \alias{Logic,ANY,nanotime-method} \alias{Math,nanotime-method} \alias{Math2,nanotime-method} \alias{Summary,nanotime-method} \alias{min,nanotime-method} \alias{max,nanotime-method} \alias{range,nanotime-method} \alias{Complex,nanotime-method} \alias{[[,nanotime-method} \alias{[,nanotime,numeric-method} \alias{[,nanotime,logical-method} \alias{[,nanotime,character-method} \alias{[,nanotime,ANY-method} \alias{[<-,nanotime,ANY,ANY,ANY-method} \alias{c.nanotime} \alias{nanotime-package} \alias{names<-,nanotime-method} \alias{is.na,nanotime-method} \alias{NA_nanotime_} \alias{as.character.nanotime} \alias{as.data.frame.nanoduration} \title{Nanosecond resolution datetime functionality} \format{ An object of class \code{nanotime} of length 1. } \usage{ nanotime(from, ...) as.nanotime(from, ...) \S4method{nanotime}{character}(from, format = "", tz = "") \S4method{as.nanotime}{character}(from, format = "", tz = "") nanotime.matrix(x) \S4method{nanotime}{POSIXct}(from) \S4method{as.nanotime}{POSIXct}(from) \S4method{nanotime}{POSIXlt}(from) \S4method{as.nanotime}{POSIXlt}(from) \S4method{nanotime}{Date}(from) \S4method{as.nanotime}{Date}(from) \S4method{print}{nanotime}(x, format = "", tz = "", quote = FALSE, ...) \S4method{show}{nanotime}(object) \method{format}{nanotime}(x, format = "", tz = "", ...) \method{index2char}{nanotime}(x, ...) \method{as.POSIXct}{nanotime}(x, tz = "", ...) \method{as.POSIXlt}{nanotime}(x, tz = "", ...) \method{as.Date}{nanotime}(x, ...) \method{as.data.frame}{nanotime}(x, ...) \method{as.integer64}{nanotime}(x, ...) \S4method{-}{nanotime,character}(e1, e2) \S4method{-}{nanotime,nanotime}(e1, e2) \S4method{-}{nanotime,integer64}(e1, e2) \S4method{-}{nanotime,numeric}(e1, e2) \S4method{-}{ANY,nanotime}(e1, e2) \S4method{-}{nanotime,ANY}(e1, e2) \S4method{+}{nanotime,ANY}(e1, e2) \S4method{+}{nanotime,integer64}(e1, e2) \S4method{+}{nanotime,numeric}(e1, e2) \S4method{+}{ANY,nanotime}(e1, e2) \S4method{+}{integer64,nanotime}(e1, e2) \S4method{+}{numeric,nanotime}(e1, e2) \S4method{+}{nanotime,nanotime}(e1, e2) \S4method{Arith}{nanotime,nanotime}(e1, e2) \S4method{Arith}{nanotime,ANY}(e1, e2) \S4method{Arith}{ANY,nanotime}(e1, e2) \S4method{Compare}{nanotime,character}(e1, e2) \S4method{Compare}{character,nanotime}(e1, e2) \S4method{Compare}{nanotime,POSIXt}(e1, e2) \S4method{Compare}{POSIXt,nanotime}(e1, e2) \S4method{Compare}{nanotime,ANY}(e1, e2) \S4method{Logic}{nanotime,ANY}(e1, e2) \S4method{Logic}{ANY,nanotime}(e1, e2) \S4method{Math}{nanotime}(x) \S4method{Math2}{nanotime}(x, digits) \S4method{Summary}{nanotime}(x, ..., na.rm = FALSE) \S4method{min}{nanotime}(x, ..., na.rm = FALSE) \S4method{max}{nanotime}(x, ..., na.rm = FALSE) \S4method{range}{nanotime}(x, ..., na.rm = FALSE) \S4method{Complex}{nanotime}(z) \S4method{[[}{nanotime}(x, i, j, ..., drop = FALSE) \S4method{[}{nanotime,numeric}(x, i, j, ..., drop = FALSE) \S4method{[}{nanotime,logical}(x, i, j, ..., drop = FALSE) \S4method{[}{nanotime,character}(x, i, j, ..., drop = FALSE) \S4method{[}{nanotime,ANY}(x, i, j, ..., drop = FALSE) \S4method{[}{nanotime,ANY,ANY,ANY}(x, i, j, ...) <- value \method{c}{nanotime}(...) \S4method{names}{nanotime}(x) <- value \S4method{is.na}{nanotime}(x) NA_nanotime_ \method{as.character}{nanotime}(x, ...) \method{as.data.frame}{nanoduration}(x, ...) } \arguments{ \item{...}{further arguments passed to or from methods.} \item{format}{A character string. Can also be set via \code{options("nanotimeFormat")} and uses \sQuote{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez} as a default and fallback} \item{tz}{character specifying a timezone which is required for \code{as.POSIXct}, \code{as.POSIXlt} and can be specified for \code{as.nanotime}, \code{format} and \code{print}; it can also be set via \code{options("nanotimeTz")} and uses \sQuote{UTC} as a default and fallback} \item{x, from}{\code{nanotime} objects} \item{quote}{indicates if the output of \code{print} should be quoted} \item{object}{argument for method \code{show}} \item{e1}{Operand of class \code{nanotime}} \item{e2}{Operand of class \code{nanotime}} \item{digits}{Required for \code{Math2} signature but ignored here} \item{na.rm}{a logical indicating whether missing values should be removed.} \item{z}{Required for \code{Complex} signature but ignored here} \item{i}{index specifying elements to extract or replace.} \item{j}{Required for \code{[} signature but ignored here} \item{drop}{Required for \code{[} signature but ignored here} \item{value}{argument for \code{nanotime-class}} } \value{ A nanotime object } \description{ Functions to operate on nanosecond time resolution using integer64 bit representation. Conversion functions for several standard R types are provided, and more will be added as needed. } \details{ Notice that the conversion from POSIXct explicitly sets the last three digits to zero. Nanosecond time stored in a 64-bit integer has nineteen digits precision where doubles (which are used internally for POSIXct as well) only have sixteen digits. So rather than showing three more (essentially \emph{random}) digits it is constructed such that these three additional digits are zeros. } \section{Caveats}{ Working with dates and times is \emph{difficult}. One needs a representation of both \emph{time points} and \emph{time duration}. In R, think of \code{Date} or \code{POSIXct} objects for the former, and \code{difftime} for the later. Here we have time points \code{nanotime}, an interval type \code{nanoival} and two flavors of duration which are a simple count of nanoseconds \code{nanoduration} and a calendar duration that is able to track concepts such as months and days \code{nanoperiod}. Point in time and intervals are all based on durations relative to the epoch of January 1, 1970. } \section{Input and Output Format}{ Formatting and character conversion for \code{nanotime} objects is done by functions from the \code{\link{RcppCCTZ}} package relying on code from its embedded \code{CCTZ} library. The default format is ISO3339 compliant: \code{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez}. It specifies a standard ISO 8601 part for date and time --- as well as nine digits of precision for fractional seconds (down to nanoseconds) and on offset (typically zero as we default to UTC). It can be overriden by using \code{options()} with the key of \code{nanotimeFormat} and a suitable value. Similarly, \code{nanotimeTz} can be used to select a different timezone. For input, some slack it cut, and various shortened formats are accepted by default such as \code{2020-03-10} or \code{2020-03-10 18:16:00}, or \code{2020-03-10 18:16:00.001} (and the \sQuote{T} separator is optional. } \section{\code{tz} parameter usage in constructors}{ The \code{tz} parameter is allowed only when constructing a \code{nanotime} from a \code{character}. This is because any \code{numeric}, \code{Date} and \code{POSIXct} is de facto considered an offset since the epoch. On the contrary, a \code{character} is considered interpretable and hence if it does not contain a timezone in its representation, it is possible to specify the \code{tz} argument to specify in which timezone it should be interpreted. This is useful in particular if one wants to convert a \code{Date} to be aligned to the beginning of the day in a specific timezone; in this case one should convert the \code{Date} to a \code{character} before calling the \code{nanotime} constructor with the desired timezone. } \examples{ \dontrun{ x <- nanotime(1) print(x) as.nanotime("1970-01-01T00:00:00.000000001+00:00") as.nanotime("2020-03-10 Europe/Berlin") as.nanotime("2020-03-10 18:31:23.001", tz="America/New_York") x <- x + 1 print(x) format(x) x <- x + 10 print(x) format(x) nanotime(Sys.time()) + 1:3 # three elements each 1 ns apart seq(x, by=as.nanoperiod("1d"), length.out=5, tz="Asia/Tokyo") } } \seealso{ \code{\link{nanoival}}, \code{\link{nanoduration}}, \code{\link{nanoperiod}}, \code{\link{seq.nanotime}} } \author{ Dirk Eddelbuettel Leonardo Silvestri } \keyword{datasets} nanotime/man/is.unsorted-nanoival-method.Rd0000644000176200001440000000120613636243601020471 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoival.R \name{is.unsorted,nanoival-method} \alias{is.unsorted,nanoival-method} \title{Test if a \code{nanoival} vector is Not Sorted} \usage{ \S4method{is.unsorted}{nanoival}(x, na.rm = FALSE, strictly = FALSE) } \arguments{ \item{x}{a \code{nanoival} vector} \item{na.rm}{logical. Should missing values be removed before checking?} \item{strictly}{logical indicating if the check should be for _strictly_ increasing values.} } \description{ Test if an object is not sorted (in increasing order), without the cost of sorting it. } \seealso{ \code{\link{sort}} } nanotime/man/rep-nanotime-method.Rd0000644000176200001440000000226013660243672017013 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanotime.R \name{rep,nanotime-method} \alias{rep,nanotime-method} \title{Replicate Elements} \usage{ \S4method{rep}{nanotime}(x, ...) } \arguments{ \item{x}{a vector of \code{nanotime}} \item{...}{further arguments: 'times' an integer-valued vector giving the (non-negative) number of times to repeat each element if of length 'length(x)', or to repeat the whole vector if of length 1. Negative or 'NA' values are an error. A 'double' vector is accepted, other inputs being coerced to an integer or double vector. 'length.out' non-negative integer. The desired length of the output vector. Other inputs will be coerced to a double vector and the first element taken. Ignored if 'NA' or invalid. 'each' non-negative integer. Each element of 'x' is repeated 'each' times. Other inputs will be coerced to an integer or double vector and the first element taken. Treated as '1' if 'NA' or invalid.} } \description{ Replicates the values in 'x' similarly to the default method. } nanotime/man/all.equal.nanoival.Rd0000644000176200001440000000220113643724064016616 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoival.R \name{all.equal.nanoival} \alias{all.equal.nanoival} \alias{all.equal,nanoival-method} \title{Test if Two Objects are (Nearly) Equal} \usage{ \method{all.equal}{nanoival}(target, current, ..., check.attributes = TRUE) \S4method{all.equal}{nanoival}(target, current, ..., check.attributes = TRUE) } \arguments{ \item{target, current}{\code{nanoival} arguments to be compared} \item{...}{further arguments for different methods} \item{check.attributes}{logical indicating if the \code{attributes} of \code{target} and \code{current} (other than the names) should be compared.} } \description{ Compare \code{target} and \code{current} testing \sQuote{near equality}. If they are different, comparison is still made to some extent, and a report of the differences is returned. Do not use \code{all.equal} directly in \code{if} expressions---either use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if appropriate. } \seealso{ \code{\link{identical}}, \code{\link{isTRUE}}, \code{\link{==}}, and \code{\link{all}} for exact equality testing. } nanotime/man/nano_year.Rd0000644000176200001440000000324413714017251015105 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanotime.R \name{nano_wday} \alias{nano_wday} \alias{nano_wday,nanotime-method} \alias{nano_mday,nanotime-method} \alias{nano_month,nanotime-method} \alias{nano_year,nanotime-method} \alias{nano_mday} \alias{nano_month} \alias{nano_year} \title{Get a component of a date time} \usage{ nano_wday(x, tz) nano_mday(x, tz) nano_month(x, tz) nano_year(x, tz) } \arguments{ \item{x}{a \code{nanotime} object} \item{tz}{\code{character} a string representing a timezone} } \description{ Get a component of a date time. \code{nano_wday} returns the numeric position in a week, with Sunday == 0. \code{nano_mday} returns the numeric day (i.e. a value from 1 to 31). \code{nano_month} returns the month (i.e. a value from 1 to 12). \code{nano_year} returns the year. } \details{ Note that the \code{tz} parameter is mandatory because the day boundary is different depending on the time zone and \code{nanotime} does not store the timezone as it is just an offset in nanoseconds from the epoch. } \examples{ \dontrun{ nano_wday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/New_York") nano_wday(as.nanotime("2020-03-14 23:32:00 America/New_York"), "Europe/Paris") nano_mday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/New_York") nano_mday(as.nanotime("2020-03-14 23:32:00 America/New_York"), "Europe/Paris") nano_month(as.nanotime("2020-12-31 23:32:00-04:00"), "America/New_York") nano_month(as.nanotime("2020-12-31 23:32:00 America/New_York"), "Europe/Paris") nano_year(as.nanotime("2020-12-31 23:32:00-04:00"), "America/New_York") nano_year(as.nanotime("2020-12-31 23:32:00 America/New_York"), "Europe/Paris") } } nanotime/man/sort-nanoival-method.Rd0000644000176200001440000000076713636243601017216 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoival.R \name{sort,nanoival-method} \alias{sort,nanoival-method} \title{Sorting or Ordering Vectors} \usage{ \S4method{sort}{nanoival}(x, decreasing = FALSE) } \arguments{ \item{x}{a vector of \code{nanoival}} \item{decreasing}{logical. Should the sort be increasing or decreasing?} } \description{ Sort (or _order_) a vector of \code{nanoival} into ascending or descending order } \seealso{ \code{\link{is.unsorted}} } nanotime/man/rep-nanoduration-method.Rd0000644000176200001440000000230413660243672017701 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoduration.R \name{rep,nanoduration-method} \alias{rep,nanoduration-method} \title{Replicate Elements} \usage{ \S4method{rep}{nanoduration}(x, ...) } \arguments{ \item{x}{a vector of \code{nanoduration}} \item{...}{further arguments: 'times' an integer-valued vector giving the (non-negative) number of times to repeat each element if of length 'length(x)', or to repeat the whole vector if of length 1. Negative or 'NA' values are an error. A 'double' vector is accepted, other inputs being coerced to an integer or double vector. 'length.out' non-negative integer. The desired length of the output vector. Other inputs will be coerced to a double vector and the first element taken. Ignored if 'NA' or invalid. 'each' non-negative integer. Each element of 'x' is repeated 'each' times. Other inputs will be coerced to an integer or double vector and the first element taken. Treated as '1' if 'NA' or invalid.} } \description{ Replicates the values in 'x' similarly to the default method. } nanotime/man/all.equal.nanotime.Rd0000644000176200001440000000425413643724064016633 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanotime.R \name{all.equal.nanotime} \alias{all.equal.nanotime} \alias{all.equal,nanotime-method} \title{Test if Two Objects are (Nearly) Equal} \usage{ \method{all.equal}{nanotime}( target, current, tolerance = sqrt(.Machine$double.eps), scale = NULL, countEQ = FALSE, formatFUN = function(err, what) format(err), ..., check.attributes = TRUE ) \S4method{all.equal}{nanotime}( target, current, tolerance = sqrt(.Machine$double.eps), scale = NULL, countEQ = FALSE, formatFUN = function(err, what) format(err), ..., check.attributes = TRUE ) } \arguments{ \item{target, current}{\code{nanotime} arguments to be compared} \item{tolerance}{numeric >= 0. Differences smaller than \code{tolerance} are not reported. The default value is close to \code{1.5e-8}.} \item{scale}{\code{NULL} or numeric > 0, typically of length 1 or \code{length(target)}. See \sQuote{Details}.} \item{countEQ}{logical indicating if the \code{target == current} cases should be counted when computing the mean (absolute or relative) differences. The default, \code{FALSE} may seem misleading in cases where \code{target} and \code{current} only differ in a few places; see the extensive example.} \item{formatFUN}{a \code{function} of two arguments, \code{err}, the relative, absolute or scaled error, and \code{what}, a character string indicating the _kind_ of error; maybe used, e.g., to format relative and absolute errors differently.} \item{...}{further arguments for different methods} \item{check.attributes}{logical indicating if the \code{attributes} of \code{target} and \code{current} (other than the names) should be compared.} } \description{ Compare \code{target} and \code{current} testing \sQuote{near equality}. If they are different, comparison is still made to some extent, and a report of the differences is returned. Do not use \code{all.equal} directly in \code{if} expressions---either use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if appropriate. } \seealso{ \code{\link{identical}}, \code{\link{isTRUE}}, \code{\link{==}}, and \code{\link{all}} for exact equality testing. } nanotime/man/set_operations.Rd0000644000176200001440000000743014211166045016170 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoival.R \name{intersect,nanoival,nanoival-method} \alias{intersect,nanoival,nanoival-method} \alias{union,nanoival,nanoival-method} \alias{setdiff,nanoival,nanoival-method} \alias{intersect.idx,nanotime,nanoival-method} \alias{intersect.idx} \alias{\%in\%.nanotime} \alias{\%in\%,nanotime,nanoival-method} \alias{intersect,nanotime,nanoival-method} \alias{setdiff,nanotime,nanoival-method} \alias{setdiff.idx,nanotime,nanoival-method} \alias{setdiff.idx} \alias{intersect,nanotime,nanotime-method} \alias{union,nanotime,nanotime-method} \alias{setdiff,nanotime,nanotime-method} \title{Set operations} \usage{ \S4method{intersect}{nanoival,nanoival}(x, y) \S4method{union}{nanoival,nanoival}(x, y) \S4method{setdiff}{nanoival,nanoival}(x, y) \S4method{intersect.idx}{nanotime,nanoival}(x, y) \method{\%in\%}{nanotime}(x, table) \S4method{\%in\%}{nanotime,nanoival}(x, table) \S4method{intersect}{nanotime,nanoival}(x, y) \S4method{setdiff}{nanotime,nanoival}(x, y) \S4method{setdiff.idx}{nanotime,nanoival}(x, y) \S4method{intersect}{nanotime,nanotime}(x, y) \S4method{union}{nanotime,nanotime}(x, y) \S4method{setdiff}{nanotime,nanotime}(x, y) } \arguments{ \item{x, y}{a temporal type} \item{table}{\code{nanoival}: used in \code{\%in\%}} } \value{ \code{intersect}, \code{union}, \code{setdiff} return temporal types that are the result of the intersection. For instance, set operations on two \code{nanoival} return a \code{nanoival}, whereas intersection between a \code{nanoival} and a \code{nanotime} returns a \code{nanotime}. \code{intersect.idx} return a list of vectors representing the element indices that intersect and \code{setdiff.idx} returns a vector representing the element indices to be removed. } \description{ Performs set intersection, union and difference between vectors of temporal types from the \code{nanotime} package. } \details{ Set operations between \code{nanoival} operands allow the construction of complex interval vectors (i.e. a \code{nanoival} vector can specify any number of inclusions and exclusions of time). Set operations between \code{nanotime} and \code{nanoival} allow to subset time vectors with interval vectors. In addition to the generic set functions, the function \code{intersect.idx} is defined which returns the indices of the intersection, and the operator \code{\%in\%} is overloaded for \code{nanotime-nanoival} which returns a logical vector that indicates which elements belong to the interval vector. } \examples{ \dontrun{ ## a vector of 'nanotime' can be subsetted by a 'nanoival' which is equivalent to 'intersect': one_second <- 1e9 a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) idx <- c(as.nanoival("-2012-12-12 12:12:10+00:00 -> 2012-12-12 12:12:14+00:00-"), as.nanoival("+2012-12-12 12:12:18+00:00 -> 2012-12-12 12:12:20+00:00+")) a[idx] intersect(a, idx) ## 'nanoival' also has the set operations 'union', 'intersect', 'setdiff': a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) i <- as.nanoival("-2012-12-12 12:12:14+00:00 -> 2012-12-12 12:12:18+00:00-") setdiff(a, i) i1 <- as.nanoival("+2012-12-12 12:12:14+00:00 -> 2012-12-12 12:12:17+00:00-") i2 <- as.nanoival("+2012-12-12 12:12:16+00:00 -> 2012-12-12 12:12:18+00:00-") union(i1, i2) ## 'intersect.idx' returns the indices of the intersection: a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) idx <- as.nanoival("+2012-12-12 12:12:14+00:00 -> 2012-12-12 12:12:19+00:00+") idx_intersect <- intersect.idx(a, idx) ## Intersection can be performed using these indices: a[idx_intersect$x] ## which is equivalent to: a[idx] ## The logical vector indicating intersection can be obtained like this: a \%in\% idx } } nanotime/man/all.equal.nanoperiod.Rd0000644000176200001440000000221713643724064017154 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoperiod.R \name{all.equal.nanoperiod} \alias{all.equal.nanoperiod} \alias{all.equal,nanoperiod-method} \title{Test if Two Objects are (Nearly) Equal} \usage{ \method{all.equal}{nanoperiod}(target, current, ..., check.attributes = TRUE) \S4method{all.equal}{nanoperiod}(target, current, ..., check.attributes = TRUE) } \arguments{ \item{target, current}{\code{nanoperiod} arguments to be compared} \item{...}{further arguments for different methods} \item{check.attributes}{logical indicating if the \code{attributes} of \code{target} and \code{current} (other than the names) should be compared.} } \description{ Compare \code{target} and \code{current} testing \sQuote{near equality}. If they are different, comparison is still made to some extent, and a report of the differences is returned. Do not use \code{all.equal} directly in \code{if} expressions---either use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if appropriate. } \seealso{ \code{\link{identical}}, \code{\link{isTRUE}}, \code{\link{==}}, and \code{\link{all}} for exact equality testing. } nanotime/man/seq-nanoival-method.Rd0000644000176200001440000000213613714017251017004 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoival.R \name{seq,nanoival-method} \alias{seq,nanoival-method} \title{Sequence Generation} \usage{ \S4method{seq}{nanoival}(from, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...) } \arguments{ \item{from, to}{the starting and (maximal) end values of the sequence} \item{by}{\code{nanoduration} or \code{nanoperiod} increment of the sequence; note that if the class is \code{nanoperiod} the additional argument \code{tz} must be speficied and is of \code{character} type indicating a timezone} \item{length.out}{an integer desired length of the sequence} \item{along.with}{take the length from the length of this argument.} \item{...}{arguments passed to or from methods; the only interesting additional argument is \code{tz} where the \code{to} argument is of type \code{nanoperiod}} } \description{ Generate a sequence of \code{nanoival} } \examples{ \dontrun{ from <- as.nanoival("-2018-01-14T13:00:00+00:00 -> 2018-01-14T15:00:00+00:00+") seq(from, by=as.nanoperiod("1m"), length.out=5, tz="America/New_York") } } nanotime/man/seq.nanoduration.Rd0000644000176200001440000000135213636243601016423 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoduration.R \name{seq.nanoduration} \alias{seq.nanoduration} \title{Sequence Generation} \usage{ \method{seq}{nanoduration}(from, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...) } \arguments{ \item{from, to}{the starting and (maximal) end values of the sequence} \item{by}{the increment of the sequence} \item{length.out}{integer indicating the desired length of the sequence} \item{along.with}{take the length from the length of this argument.} \item{...}{arguments passed to or from methods} } \description{ Generate a sequence of \code{nanoduration} } \examples{ seq(from=as.nanoduration(0), by=as.nanoduration("01:00:00"), length.out=10) } nanotime/man/rounding.Rd0000644000176200001440000001152013723471745014767 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanotime.R, R/nanoduration.R, R/nanoperiod.R \name{nano_ceiling} \alias{nano_ceiling} \alias{nano_floor} \alias{nano_ceiling,nanotime,nanoduration-method} \alias{nano_floor,nanotime,nanoduration-method} \alias{nano_ceiling,nanotime,nanoperiod-method} \alias{nano_floor,nanotime,nanoperiod-method} \title{Rounding down or up a \code{nanotime} type} \usage{ nano_ceiling(x, precision, ...) nano_floor(x, precision, ...) \S4method{nano_ceiling}{nanotime,nanoduration}(x, precision, origin = nanotime()) \S4method{nano_floor}{nanotime,nanoduration}(x, precision, origin = nanotime()) \S4method{nano_ceiling}{nanotime,nanoperiod}(x, precision, origin = nanotime(), tz) \S4method{nano_floor}{nanotime,nanoperiod}(x, precision, origin = nanotime(), tz) } \arguments{ \item{x}{a \code{nanotime} object which must be sorted} \item{precision}{a \code{nanoduration} or \code{nanoperiod} object indicating the rounding precision} \item{...}{for future additional arguments} \item{origin}{a \code{nanotime} scalar indicating the origin at which the rounding is considered} \item{tz}{a \code{character} scalar indicating the time zone in which to conduct the rounding} } \description{ The functions \code{nano_floor} and \code{nano_ceiling} round down or up, respectively. Although the underlying implementation of \code{nanotime} has negative numbers for values before 1970-01-01 UTC, the rounding is always done backward in time for \code{nano_floor} and forward in time for \code{nano_ceiling}. The functions take a \code{nanotime} argument \code{x} which is the instance to round, together with a second argument \code{precision} which indicates an arbitrary precision to which the rounding should be performed. This argument can be either a \code{nanoduration} or or a \code{nanoperiod}. In the latter case, the argument \code{tz} must also be specified in order to give the \code{nanoperiod} a meaning. Finally, the \code{nanotime} argument \code{origin} can be optionally specified to fix the rounding to a specific point in time. } \details{ This flexible rounding must be understood in the context of a vector. The rounding precision can then be considered as an interval that defines a grid over which the elements are either assigned to the starting value of the interval to which they belong (\code{nano_floor}) or the ending value of the interval to which they belong (\code{nano_ceiling}). This allows for a grouping of a \code{nanotime} vector on which a statistic may then be run. In the examples below, such a use case is shown in the context of a \code{data.table} object. If "business" concepts such as month or days are needed, the \code{argument} precision must be of type \code{period}. It is then mandatory to specify the timezone argument \code{tz} as this ensures timezone correctness of the intervals including for example for the rare hourly transitions of some countries going from a timezone with a whole hour difference with UTC to one with a fractional hour difference. In the case of a \code{period}, the functions align the rounding if the precision is an integer divisor of a larger quantity. For instance, if one specifies a rounding of 6 hours, a divisor of a day, the hours are aligned on days and the rounding is made to a grid at hours 0, 6, 12 and 18 in the specified timezone. If the precision is not a divisor, the grid is aligned to the nearest hour before the first element of the vector to round. The argument \code{origin} controls the reference point of the rounding, allowing arbitrary specification of the reference point of the rounding. } \examples{ \dontrun{ ## "classic" rounding: nano_floor(as.nanotime("2010-10-10 11:12:15 UTC"), as.nanoduration("01:00:00")) ## rounding with arbitrary precision: nano_floor(as.nanotime("2010-10-10 11:12:15 UTC"), as.nanoduration("06:00:00")) nano_floor(as.nanotime("2010-10-10 11:23:15 UTC"), as.nanoduration("00:15:00")) nano_ceiling(as.nanotime("2010-10-10 11:23:15 UTC"), as.nanoduration("01:15:23")) ## controlling the reference point via the 'origin' argument: nano_ceiling(as.nanotime("2010-10-10 11:23:15 UTC"), as.nanoduration("01:15:23"), origin=as.nanotime("2010-10-10 11:23:15 UTC")) ## using business concepts and rounding across a daylight saving change: v <- seq(as.nanotime("2020-03-08 America/New_York"), by=as.nanoperiod("06:00:00"), length.out=8, tz="America/New_York") print(nano_floor(v, as.nanoperiod("1d"), tz="America/New_York"), tz="America/New_York") ## using the concept in a 'data.table': library(data.table) n <- 3 * 24 idx <- seq(as.nanotime("2020-03-07 America/New_York"), by=as.nanoperiod("01:00:00"), length.out=n, tz="America/New_York") dt <- data.table(idx, a=1:n, b=2:(n+1)) dt_mean <- dt[, list(mean = mean(a)), by=nano_ceiling(idx, as.nanoperiod("1d"), tz="America/New_York")] } } nanotime/man/all.equal.nanoduration.Rd0000644000176200001440000000431013643724064017513 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoduration.R \name{all.equal.nanoduration} \alias{all.equal.nanoduration} \alias{all.equal,nanoduration-method} \title{Test if Two Objects are (Nearly) Equal} \usage{ \method{all.equal}{nanoduration}( target, current, tolerance = sqrt(.Machine$double.eps), scale = NULL, countEQ = FALSE, formatFUN = function(err, what) format(err), ..., check.attributes = TRUE ) \S4method{all.equal}{nanoduration}( target, current, tolerance = sqrt(.Machine$double.eps), scale = NULL, countEQ = FALSE, formatFUN = function(err, what) format(err), ..., check.attributes = TRUE ) } \arguments{ \item{target, current}{\code{nanoduration} arguments to be compared} \item{tolerance}{numeric >= 0. Differences smaller than \code{tolerance} are not reported. The default value is close to \code{1.5e-8}.} \item{scale}{\code{NULL} or numeric > 0, typically of length 1 or \code{length(target)}. See \sQuote{Details}.} \item{countEQ}{logical indicating if the \code{target == current} cases should be counted when computing the mean (absolute or relative) differences. The default, \code{FALSE} may seem misleading in cases where \code{target} and \code{current} only differ in a few places; see the extensive example.} \item{formatFUN}{a \code{function} of two arguments, \code{err}, the relative, absolute or scaled error, and \code{what}, a character string indicating the _kind_ of error; maybe used, e.g., to format relative and absolute errors differently.} \item{...}{further arguments for different methods} \item{check.attributes}{logical indicating if the \code{attributes} of \code{target} and \code{current} (other than the names) should be compared.} } \description{ Compare \code{target} and \code{current} testing \sQuote{near equality}. If they are different, comparison is still made to some extent, and a report of the differences is returned. Do not use \code{all.equal} directly in \code{if} expressions---either use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if appropriate. } \seealso{ \code{\link{identical}}, \code{\link{isTRUE}}, \code{\link{==}}, and \code{\link{all}} for exact equality testing. } nanotime/man/nanoduration.Rd0000644000176200001440000002135214323545236015641 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoduration.R \docType{class} \name{nanoduration-class} \alias{nanoduration-class} \alias{nanoduration} \alias{*,ANY,nanoduration-method} \alias{*,nanoduration,ANY-method} \alias{*,nanoduration,nanoduration-method} \alias{+,ANY,nanoduration-method} \alias{/,ANY,nanoduration-method} \alias{/,nanoduration,ANY-method} \alias{Complex,nanoduration-method} \alias{Logic,ANY,nanoduration-method} \alias{Logic,nanoduration,ANY-method} \alias{Logic,nanoduration,nanoduration-method} \alias{Math2,nanoduration-method} \alias{Math,nanoduration-method} \alias{Summary,nanoduration-method} \alias{as.nanoduration,character-method} \alias{as.nanoduration} \alias{as.nanoduration,integer64-method} \alias{as.nanoduration,numeric-method} \alias{as.nanoduration,integer-method} \alias{as.nanoduration,difftime-method} \alias{as.nanoduration,NULL-method} \alias{as.nanoduration,missing-method} \alias{show,nanoduration-method} \alias{print,nanoduration-method} \alias{format.nanoduration} \alias{as.integer64.nanoduration} \alias{as.character,nanoduration-method} \alias{is.na,nanoduration-method} \alias{-,nanoduration,nanoduration-method} \alias{-,nanoduration,integer64-method} \alias{-,nanoduration,integer-method} \alias{-,nanoduration,numeric-method} \alias{-,nanoduration,difftime-method} \alias{-,nanoduration,ANY-method} \alias{-,nanotime,nanoduration-method} \alias{-,nanotime,difftime-method} \alias{-,integer64,nanoduration-method} \alias{-,integer,nanoduration-method} \alias{-,numeric,nanoduration-method} \alias{-,difftime,nanoduration-method} \alias{-,ANY,nanoduration-method} \alias{+,nanoduration,ANY-method} \alias{+,nanoduration,nanoduration-method} \alias{+,nanoduration,integer64-method} \alias{+,nanoduration,numeric-method} \alias{+,nanoduration,difftime-method} \alias{+,nanotime,nanoduration-method} \alias{+,nanotime,difftime-method} \alias{+,nanoduration,nanotime-method} \alias{+,difftime,nanotime-method} \alias{+,nanoival,nanoduration-method} \alias{-,nanoival,nanoduration-method} \alias{+,nanoduration,nanoival-method} \alias{+,nanoival,difftime-method} \alias{-,nanoival,difftime-method} \alias{+,difftime,nanoival-method} \alias{+,integer64,nanoduration-method} \alias{+,numeric,nanoduration-method} \alias{+,difftime,nanoduration-method} \alias{*,nanoduration,numeric-method} \alias{*,nanoduration,integer64-method} \alias{*,numeric,nanoduration-method} \alias{*,integer64,nanoduration-method} \alias{/,nanoduration,nanoduration-method} \alias{/,nanoduration,integer64-method} \alias{/,nanoduration,numeric-method} \alias{Arith,nanoduration,ANY-method} \alias{Compare,nanoduration,character-method} \alias{Compare,character,nanoduration-method} \alias{Compare,nanoduration,ANY-method} \alias{abs,nanoduration-method} \alias{sign,nanoduration-method} \alias{sum,nanoduration-method} \alias{min,nanoduration-method} \alias{max,nanoduration-method} \alias{range,nanoduration-method} \alias{[[,nanoduration-method} \alias{[,nanoduration,numeric-method} \alias{[,nanoduration,logical-method} \alias{[,nanoduration,character-method} \alias{[,nanoduration,ANY-method} \alias{[<-,nanoduration,ANY,ANY,ANY-method} \alias{c.nanoduration} \alias{NA_nanoduration_} \title{Duration type with nanosecond precision} \format{ An object of class \code{nanoduration} of length 1. } \usage{ nanoduration(hours = 0L, minutes = 0L, seconds = 0L, nanoseconds = 0L) \S4method{as.nanoduration}{character}(x) \S4method{as.nanoduration}{integer64}(x) \S4method{as.nanoduration}{numeric}(x) \S4method{as.nanoduration}{integer}(x) \S4method{as.nanoduration}{difftime}(x) \S4method{as.nanoduration}{`NULL`}(x) \S4method{as.nanoduration}{missing}(x) \S4method{show}{nanoduration}(object) \S4method{print}{nanoduration}(x, quote = FALSE, ...) \method{format}{nanoduration}(x, ...) \method{as.integer64}{nanoduration}(x, ...) \S4method{as.character}{nanoduration}(x) \S4method{is.na}{nanoduration}(x) \S4method{-}{nanoduration,nanoduration}(e1, e2) \S4method{-}{nanoduration,integer64}(e1, e2) \S4method{-}{nanoduration,integer}(e1, e2) \S4method{-}{nanoduration,numeric}(e1, e2) \S4method{-}{nanoduration,difftime}(e1, e2) \S4method{-}{nanoduration,ANY}(e1, e2) \S4method{-}{nanotime,nanoduration}(e1, e2) \S4method{-}{nanotime,difftime}(e1, e2) \S4method{-}{integer64,nanoduration}(e1, e2) \S4method{-}{integer,nanoduration}(e1, e2) \S4method{-}{numeric,nanoduration}(e1, e2) \S4method{-}{difftime,nanoduration}(e1, e2) \S4method{-}{ANY,nanoduration}(e1, e2) \S4method{+}{nanoduration,ANY}(e1, e2) \S4method{+}{nanoduration,nanoduration}(e1, e2) \S4method{+}{nanoduration,integer64}(e1, e2) \S4method{+}{nanoduration,numeric}(e1, e2) \S4method{+}{nanoduration,difftime}(e1, e2) \S4method{+}{nanotime,nanoduration}(e1, e2) \S4method{+}{nanotime,difftime}(e1, e2) \S4method{+}{nanoduration,nanotime}(e1, e2) \S4method{+}{difftime,nanotime}(e1, e2) \S4method{+}{nanoival,nanoduration}(e1, e2) \S4method{-}{nanoival,nanoduration}(e1, e2) \S4method{+}{nanoduration,nanoival}(e1, e2) \S4method{+}{nanoival,difftime}(e1, e2) \S4method{-}{nanoival,difftime}(e1, e2) \S4method{+}{difftime,nanoival}(e1, e2) \S4method{+}{integer64,nanoduration}(e1, e2) \S4method{+}{numeric,nanoduration}(e1, e2) \S4method{+}{difftime,nanoduration}(e1, e2) \S4method{*}{nanoduration,numeric}(e1, e2) \S4method{*}{nanoduration,integer64}(e1, e2) \S4method{*}{numeric,nanoduration}(e1, e2) \S4method{*}{integer64,nanoduration}(e1, e2) \S4method{/}{nanoduration,nanoduration}(e1, e2) \S4method{/}{nanoduration,integer64}(e1, e2) \S4method{/}{nanoduration,numeric}(e1, e2) \S4method{Arith}{nanoduration,ANY}(e1, e2) \S4method{Compare}{nanoduration,character}(e1, e2) \S4method{Compare}{character,nanoduration}(e1, e2) \S4method{Compare}{nanoduration,ANY}(e1, e2) \S4method{abs}{nanoduration}(x) \S4method{sign}{nanoduration}(x) \S4method{sum}{nanoduration}(x, ..., na.rm = FALSE) \S4method{min}{nanoduration}(x, ..., na.rm = FALSE) \S4method{max}{nanoduration}(x, ..., na.rm = FALSE) \S4method{range}{nanoduration}(x, ..., na.rm = FALSE) \S4method{[[}{nanoduration}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoduration,numeric}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoduration,logical}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoduration,character}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoduration,ANY}(x, i, j, ..., drop = FALSE) \S4method{[}{nanoduration,ANY,ANY,ANY}(x, i, j, ...) <- value \method{c}{nanoduration}(...) NA_nanoduration_ } \arguments{ \item{hours}{number of hours} \item{minutes}{number of minutes} \item{seconds}{number of seconds} \item{nanoseconds}{number of nanoseconds} \item{x}{a \code{nanoduration} object} \item{object}{argument for method \code{show}} \item{quote}{indicates if the output of \code{print} should be quoted} \item{...}{further arguments passed to or from methods.} \item{e1}{Operand of class \code{nanoival}} \item{e2}{Operand of class \code{nanoival}} \item{na.rm}{if \code{TRUE} NA values are removed for the computation} \item{i}{index specifying elements to extract or replace.} \item{j}{Required for \code{[} signature but ignored here} \item{drop}{Required for \code{[} signature but ignored here} \item{value}{argument for \code{nanoduration-class}} } \value{ A nanoduration object } \description{ The type \code{nanoduration} is a length of time (implemented as an S4 class) with nanosecond precision. It is a count of nanoseconds and may be negative. The expected arithmetic operations are provided, including sequence generation. } \details{ A \code{nanoduration} can be constructed with the function \code{as.nanoduration} which can take the types \code{integer64}, \code{integer} and \code{numeric} (all indicating the count in nanosecond units) or the type \code{character}. It can also be constructed by specifying with individual arguments the hours, minutes, seconds and nanoseconds with a call to \code{nanoduration}. A \code{nanoduration} is displayed as hours, minutes, seconds and nanoseconds like this: \code{110:12:34.123_453_001}. The nanosecond precision displayed is adjusted as necessary, so e.g. 1 second is displayed as \code{00:00:01}. } \examples{ ## constructors: nanoduration(hours=10, minutes=3, seconds=2, nanoseconds=999999999) as.nanoduration("10:03:02.999_999_999") as.nanoduration(36182999999999) ## arithmetic: as.nanoduration(10e9) - as.nanoduration(9e9) as.nanoduration(10e9) + as.nanoduration(-9e9) as.nanoduration("24:00:00") / 2 as.nanoduration("24:00:00") / as.nanoduration("12:00:00") ## comparison: as.nanoduration("10:03:02.999_999_999") == 36182999999999 as.nanoduration("10:03:02.999_999_999") > as.nanoduration("10:03:02.999_999_998") as.nanoduration("10:03:02.999_999_998") < "10:03:02.999_999_999" } \seealso{ \code{\link{nanotime}} } \author{ Dirk Eddelbuettel Leonardo Silvestri } \keyword{datasets} nanotime/man/nanoperiod.month.Rd0000644000176200001440000000177413636243601016425 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoperiod.R \name{nanoperiod.month,nanoperiod-method} \alias{nanoperiod.month,nanoperiod-method} \alias{nanoperiod.month} \alias{nanoperiod.day} \alias{nanoperiod.nanoduration} \alias{nanoperiod.day,nanoperiod-method} \alias{nanoperiod.nanoduration,nanoperiod-method} \title{Nanoperiod accessors} \usage{ \S4method{nanoperiod.month}{nanoperiod}(x) \S4method{nanoperiod.day}{nanoperiod}(x) \S4method{nanoperiod.nanoduration}{nanoperiod}(x) } \arguments{ \item{x}{A \code{nanoperiod}} } \value{ \code{nanoperiod.month} and \code{nanoperiod.day} return an \code{integer64} whereas \code{nanoperiod.nanoduration} returns a \code{nanoduration} } \description{ These functions allow access to the components of a \code{nanoperiod} } \examples{ p <- as.nanoperiod("2y1m1d/12:00:00") nanoperiod.month(p) nanoperiod.day(p) nanoperiod.nanoduration(p) } \seealso{ \code{\link{nanoduration}} } \author{ Dirk Eddelbuettel Leonardo Silvestri } nanotime/man/rep-nanoival-method.Rd0000644000176200001440000000226013705574141017006 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoival.R \name{rep,nanoival-method} \alias{rep,nanoival-method} \title{Replicate Elements} \usage{ \S4method{rep}{nanoival}(x, ...) } \arguments{ \item{x}{a vector of \code{nanoival}} \item{...}{further arguments: 'times' an integer-valued vector giving the (non-negative) number of times to repeat each element if of length 'length(x)', or to repeat the whole vector if of length 1. Negative or 'NA' values are an error. A 'double' vector is accepted, other inputs being coerced to an integer or double vector. 'length.out' non-negative integer. The desired length of the output vector. Other inputs will be coerced to a double vector and the first element taken. Ignored if 'NA' or invalid. 'each' non-negative integer. Each element of 'x' is repeated 'each' times. Other inputs will be coerced to an integer or double vector and the first element taken. Treated as '1' if 'NA' or invalid.} } \description{ Replicates the values in 'x' similarly to the default method. } nanotime/man/rep-nanoperiod-method.Rd0000644000176200001440000000227213660243672017342 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/nanoperiod.R \name{rep,nanoperiod-method} \alias{rep,nanoperiod-method} \title{Replicate Elements} \usage{ \S4method{rep}{nanoperiod}(x, ...) } \arguments{ \item{x}{a vector of \code{nanoperiod}} \item{...}{further arguments: 'times' an integer-valued vector giving the (non-negative) number of times to repeat each element if of length 'length(x)', or to repeat the whole vector if of length 1. Negative or 'NA' values are an error. A 'double' vector is accepted, other inputs being coerced to an integer or double vector. 'length.out' non-negative integer. The desired length of the output vector. Other inputs will be coerced to a double vector and the first element taken. Ignored if 'NA' or invalid. 'each' non-negative integer. Each element of 'x' is repeated 'each' times. Other inputs will be coerced to an integer or double vector and the first element taken. Treated as '1' if 'NA' or invalid.} } \description{ Replicates the values in 'x' similarly to the default method. } nanotime/DESCRIPTION0000644000176200001440000000210514325434233013573 0ustar liggesusersPackage: nanotime Type: Package Title: Nanosecond-Resolution Time Support for R Version: 0.3.7 Date: 2022-10-23 Author: Dirk Eddelbuettel and Leonardo Silvestri Maintainer: Dirk Eddelbuettel Description: Full 64-bit resolution date and time functionality with nanosecond granularity is provided, with easy transition to and from the standard 'POSIXct' type. Three additional classes offer interval, period and duration functionality for nanosecond-resolution timestamps. Imports: methods, bit64, RcppCCTZ (>= 0.2.9), zoo Suggests: tinytest, data.table, xts LinkingTo: Rcpp, RcppCCTZ, RcppDate License: GPL (>= 2) URL: https://github.com/eddelbuettel/nanotime, https://eddelbuettel.github.io/nanotime/, https://dirk.eddelbuettel.com/code/nanotime.html BugReports: https://github.com/eddelbuettel/nanotime/issues RoxygenNote: 7.1.2 Collate: 'nanotime.R' 'nanoival.R' 'nanoduration.R' 'nanoperiod.R' 'RcppExports.R' Encoding: UTF-8 NeedsCompilation: yes Packaged: 2022-10-24 00:26:28 UTC; edd Repository: CRAN Date/Publication: 2022-10-24 07:02:51 UTC nanotime/build/0000755000176200001440000000000014325355664013200 5ustar liggesusersnanotime/build/vignette.rds0000644000176200001440000000040614325355664015537 0ustar liggesusers‹ŤQÁŠÂ0LŰč¶uzqoýű"—E= "1.0.0") { ## Set a seed to make the test deterministic set.seed(42) ## R makes us to this Sys.setenv("R_TESTS"="") ## there are several more granular ways to test files in a tinytest directory, ## see its package vignette; tests can also run once the package is installed ## using the same command `test_package(pkgName)`, or by director or file tinytest::test_package("nanotime") } nanotime/tests/data.frame.R0000644000176200001440000000142013713656775015374 0ustar liggesusers library(nanotime) set.seed(42) N <- 300 shine <- nanotime(Sys.time()) + cumsum(10*rpois(n=N+1, lambda=4)) rain <- nanotime(Sys.time()) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) if (requireNamespace("data.table", quietly=TRUE)) { suppressMessages(library(data.table)) suppressMessages(library(bit64)) raw <- data.table(shine=shine, rain=rain) df <- data.frame(val=c(rain,shine), key=rep(c("rain", "shine"), each=N+1)) head(df) ## now on differences ddf <- data.frame(val=as.numeric(c(diff(rain),diff(shine))), # need to cast to numeric after diffs key=rep(c("rain", "shine"), each=N)) head(ddf) ## simpler data.frame, inserts 'formatted' newdf <- data.frame(rain=rain, shine=shine) head(newdf) } nanotime/tests/zooTests.R0000644000176200001440000000056713023270367015216 0ustar liggesusers library(nanotime) suppressMessages(library(zoo)) set.seed(42) x <- 100 + cumsum(rnorm(10)) y <- 100 + cumsum(rnorm(10)) mat <- cbind(x, y) now <- Sys.Date() z <- zoo(mat, now + 0:9) z now <- Sys.time() z <- zoo(mat, now + 0:9) z now <- nanotime(Sys.time()) z <- zoo(mat, now + 11*(0:9)) # inc. by 11 to more visible, 1 works too z nanotime/tests/simpleTests.R0000644000176200001440000000177013067732420015676 0ustar liggesusers library(nanotime) z <- RcppCCTZ:::parseDouble("1970-01-01T00:00:00.000000001+00:00") cat("z is: ") print(z) x <- nanotime("1970-01-01T00:00:00.000000001+00:00") cat("x is: ") print(x) format(x) cat("x+1 is: ") x <- x + 1 print(x) format(x) cat("y is: ") y <- nanotime(z) print(y) #print(class(y)) format(y) cat("y+1 is: ") y <- y + 1 print(y) format(y) print(x == y) od <- getOption("digits.secs") options("digits.secs"=6) as.POSIXct(x) as.POSIXct(x+1000) as.POSIXlt(x) as.POSIXlt(x+1000) as.Date(x) options("digits.secs"=od) y <- nanotime(1L) # integer, may dispatch via nanotime.numeric print(y) y <- nanotime(1) # numeric print(y) ## v <- nanotime:::nanotime.default(1) # forced call, gets imprecise value ## print(v) options("nanotimeFormat"="%Y-%m-%d %H:%M:%S") format(x <- nanotime("1970-01-01 00:00:00")) options("nanotimeFormat"="%Y-%m-%d %H:%M:%E*S") format(x <- nanotime("1970-01-01 00:00:00.123456789")) options("nanotimeFormat"="%Y-%m-%d %H:%M:%E*S%Ez") # default cat("Done\n") nanotime/tests/POSIXt.R0000644000176200001440000000047713023330507014443 0ustar liggesusers library(nanotime) format(nanotime(Sys.time()), lcltzstr="America/Chicago", tgttzstr="America/Chicago") format(nanotime(as.POSIXlt(Sys.time())), lcltzstr="America/Chicago", tgttzstr="America/Chicago") format(nanotime(Sys.Date()), lcltzstr="America/Chicago", tgttzstr="America/Chicago") nanotime/src/0000755000176200001440000000000014325355664012670 5ustar liggesusersnanotime/src/nanotime.cpp0000644000176200001440000001447613723317114015207 0ustar liggesusers#include #include #include #include #include "nanotime/globals.hpp" #include "nanotime/utilities.hpp" #include "nanotime/pseudovector.hpp" using namespace nanotime; typedef ConstPseudoVector ConstPseudoVectorInt64; typedef ConstPseudoVector ConstPseudoVectorChar; typedef ConstPseudoVector ConstPseudoVectorLgl; static inline duration getOffsetCnv(const dtime& dt, const std::string& z) { int offset; int res = RcppCCTZ::getOffset(std::chrono::duration_cast(dt.time_since_epoch()).count(), z.c_str(), offset); if (res < 0) { Rcpp::stop("Cannot retrieve timezone '%s'.", z.c_str()); } return duration(offset).count() * std::chrono::seconds(1); } // [[Rcpp::export]] Rcpp::IntegerVector nanotime_wday_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(tm_v, tz_v); Rcpp::IntegerVector res(getVectorLengths(tm_v, tz_v)); if (res.size()) { ConstPseudoVectorInt64 tm(tm_v); ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(tz[i]); const auto tm_i = *reinterpret_cast(&tm[i]); const auto offset = getOffsetCnv(tm_i, tz_i.c_str()); date::sys_days t_days = date::floor(tm_i + offset); res[i] = unsigned(date::weekday(t_days).c_encoding()); } copyNames(tm_v, tz_v, res); } return res; } // [[Rcpp::export]] Rcpp::IntegerVector nanotime_mday_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(tm_v, tz_v); Rcpp::IntegerVector res(getVectorLengths(tm_v, tz_v)); if (res.size()) { ConstPseudoVectorInt64 tm(tm_v); ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(tz[i]); const auto tm_i = *reinterpret_cast(&tm[i]); const auto offset = getOffsetCnv(tm_i, tz_i.c_str()); date::sys_days t_days = date::floor(tm_i + offset); date::weekday wd(t_days); res[i] = unsigned(date::year_month_day(t_days).day()); } copyNames(tm_v, tz_v, res); } return res; } // [[Rcpp::export]] Rcpp::IntegerVector nanotime_month_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(tm_v, tz_v); Rcpp::IntegerVector res(getVectorLengths(tm_v, tz_v)); if (res.size()) { ConstPseudoVectorInt64 tm(tm_v); ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(tz[i]); const auto tm_i = *reinterpret_cast(&tm[i]); const auto offset = getOffsetCnv(tm_i, tz_i.c_str()); date::sys_days t_days = date::floor(tm_i + offset); date::weekday wd(t_days); res[i] = unsigned(date::year_month_day(t_days).month()); } copyNames(tm_v, tz_v, res); } return res; } // [[Rcpp::export]] Rcpp::IntegerVector nanotime_year_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(tm_v, tz_v); Rcpp::IntegerVector res(getVectorLengths(tm_v, tz_v)); if (res.size()) { ConstPseudoVectorInt64 tm(tm_v); ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(tz[i]); const auto tm_i = *reinterpret_cast(&tm[i]); const auto offset = getOffsetCnv(tm_i, tz_i.c_str()); date::sys_days t_days = date::floor(tm_i + offset); date::weekday wd(t_days); res[i] = int(date::year_month_day(t_days).year()); } copyNames(tm_v, tz_v, res); } return res; } static std::int64_t readNanotime(const char*& sp, const char* const se, const char* tzstr) { auto tt = readDtime(sp, se); // check we read until the end if (sp != se) Rcpp::stop("Error parsing"); if (tt.tzstr.size() && strnlen_(tzstr, MAX_TZ_STR_LENGTH)) Rcpp::stop("timezone is specified twice: in the string and as an argument"); const cctz::civil_second cvt(tt.y, tt.m, tt.d, tt.hh, tt.mm, tt.ss); const auto final_tzstr = tt.tzstr.size() ? tt.tzstr.c_str() : tzstr; if (final_tzstr[0] == 0) Rcpp::stop("Error parsing"); cctz::time_point tp; int res = RcppCCTZ::convertToTimePoint(cvt, final_tzstr, tp); if (res < 0) { Rcpp::stop("Cannot retrieve timezone '%s'.", final_tzstr); } return (tp.time_since_epoch().count() - tt.offset) * 1000000000ll + tt.ns; } // [[Rcpp::export]] Rcpp::NumericVector nanotime_make_impl(const Rcpp::CharacterVector nt_v, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(nt_v, tz_v); Rcpp::NumericVector res(getVectorLengths(nt_v, tz_v)); if (res.size()) { ConstPseudoVectorChar nt(nt_v); ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(&t); res[i] = *ptr; } copyNames(nt_v, tz_v, res); } return assignS4("nanotime", res, "integer64"); } static double getNA_nanotime() { const int64_t i64 = std::numeric_limits::min(); double res; memcpy(&res, &i64, sizeof(res)); return res; } // [[Rcpp::export]] Rcpp::NumericVector nanotime_subset_numeric_impl(const Rcpp::NumericVector& v, const Rcpp::NumericVector& idx) { Rcpp::NumericVector res(0); std::vector res_c; // by declaring it here we can make subset logical agnostic to double subset_numeric(v, idx, res, res_c, getNA_nanotime); return assignS4("nanotime", res, "integer64"); } // [[Rcpp::export]] Rcpp::NumericVector nanotime_subset_logical_impl(const Rcpp::NumericVector& v, const Rcpp::LogicalVector& idx_p) { const ConstPseudoVectorLgl idx(idx_p); Rcpp::NumericVector res(0); std::vector res_c; // by declaring it here we can make subset logical agnostic to double subset_logical(v, idx, res, res_c, getNA_nanotime); return assignS4("nanotime", res, "integer64"); } nanotime/src/period.cpp0000644000176200001440000006503714211166045014654 0ustar liggesusers#include #include #include #include "date.h" #include #include "nanotime/period.hpp" #include "nanotime/duration.hpp" #include "nanotime/pseudovector.hpp" #include "nanotime/utilities.hpp" using namespace nanotime; // for debug reasons... // the following code from: https://stackoverflow.com/a/16692519 template std::ostream &operator<<(std::ostream &stream, const std::chrono::time_point &time_point) { const time_t time = Clock::to_time_t(time_point); #if __GNUC__ > 4 || \ ((__GNUC__ == 4) && __GNUC_MINOR__ > 8 && __GNUC_REVISION__ > 1) // Maybe the put_time will be implemented later? struct tm tm; localtime_r(&time, &tm); return stream << std::put_time(&tm, "%c"); // Print standard date&time #else char buffer[26]; ctime_r(&time, buffer); buffer[24] = '\0'; // Removes the newline that is added return stream << buffer; #endif } period::period(const std::string& str) { const char* s = str.c_str(); const char* e = s + str.size(); months = 0; days = 0; dur = std::chrono::seconds(0); int n; if (s < e && (*s == '/' || (*s != '-' && s+2 < e && s[2] == ':'))) goto getduration; // test the case where we have only a negative duration: if (s < e && *s == '-' && ((s+3 < e && s[3] == ':') || (s+2 < e && s[2] == ':'))) { --s; // because getduration will increment it goto getduration; } if (!readNumber(s, e, n, true) || s == e) throw std::range_error("cannot parse nanoperiod"); if (*s == 'y') { months += 12*n; ++s; if (s < e) { if (*s == '/') goto getduration; if (!readNumber(s, e, n, true) || s == e) throw std::range_error("cannot parse nanoperiod"); } else { return; } } if (*s == 'm') { months += n; ++s; if (s < e) { if (*s == '/') goto getduration; if (!readNumber(s, e, n, true) || s == e) throw std::range_error("cannot parse nanoperiod"); } else { return; } } if (*s == 'w') { days += 7*n; ++s; if (s < e) { if (*s == '/') goto getduration; if (!readNumber(s, e, n, true) || s == e) throw std::range_error("cannot parse nanoperiod"); } else { return; } } if (*s == 'd') { days += n; ++s; if (s < e) { if (*s == '/') goto getduration; if (!readNumber(s, e, n, true) || s == e) throw std::range_error("cannot parse nanoperiod"); } else { return; } } // we've succeeded a readNumber, so this means we've // actually read into the duration; so backtrack and use the already // existing function to parse a duration: getduration: // # nocov try { dur = from_string(++s); } catch (...) { throw std::range_error("cannot parse nanoperiod"); } } std::string nanotime::to_string(const period& p) { std::stringstream ss; ss << p.getMonths() << "m" << p.getDays() << "d/" << to_string(p.getDuration()); return ss.str(); } template period nanotime::operator*(const period& p, T d) { return period(p.getMonths()*d, p.getDays()*d, duration(static_cast(d*p.getDuration().count())* duration(1))); } template period nanotime::operator/(const period& p, T d) { if (d == 0) { throw std::logic_error("divide by zero"); } return period(p.getMonths()/d, p.getDays()/d, duration(static_cast(p.getDuration().count()/d)* duration(1))); } // bool operator>(const period& p1, const period& p2) { // // this is actually a difficult proposition, so for this calculation // // we take into account the average lengths. This means that in // // certain specific applications p1 might be <= to p2. But at any // // rate this should work for all practical purposes: // const auto YEAR = 365.25 * 24h; // const auto MONTH = YEAR/12; // return p1.getMonths()*MONTH + p1.getDays()*24h < p2.getMonths()*MONTH + p2.getDays()*24h; // } bool nanotime::operator==(const period& p1, const period& p2) { return p1.getMonths() == p2.getMonths() && p1.getDays() == p2.getDays() && p1.getDuration() == p2.getDuration(); } bool nanotime::operator!=(const period& p1, const period& p2) { return !(p1 == p2); } struct double2 { double d1; double d2; }; union period_union { struct period_alias { int32_t i1; int32_t i2; int64_t i3; } prd; double2 dbl2; }; // const int PRDSZ = sizeof(period_union)/sizeof(double); // const int INT64SZ = 1; // const int NANOSZ = 1; // const int REALSZ = 1; // see Rcpp/inst/include/Rcpp/vector/instantiation.h where NumericVector and al. are defined typedef ConstPseudoVector ConstPseudoVectorInt64; typedef ConstPseudoVector ConstPseudoVectorNano; typedef ConstPseudoVector ConstPseudoVectorPrd; typedef ConstPseudoVector ConstPseudoVectorDbl; typedef ConstPseudoVector ConstPseudoVectorIval; typedef ConstPseudoVector ConstPseudoVectorChar; typedef ConstPseudoVector ConstPseudoVectorInt; typedef ConstPseudoVector ConstPseudoVectorBool; typedef PseudoVector PseudoVectorInt64; typedef PseudoVector PseudoVectorNano; typedef PseudoVector PseudoVectorPrd; // [[Rcpp::export]] Rcpp::ComplexVector period_from_string_impl(Rcpp::CharacterVector str) { Rcpp::ComplexVector res(str.size()); for (R_xlen_t i=0; i(str[i])); period_union pu = { { prd.getMonths(), prd.getDays(), prd.getDuration().count() } }; res[i] = Rcomplex{pu.dbl2.d1, pu.dbl2.d2 }; } if (str.hasAttribute("names")) { res.names() = str.names(); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector period_from_parts_impl(Rcpp::IntegerVector months_v, Rcpp::IntegerVector days_v, Rcpp::NumericVector dur_v) { checkVectorsLengths(months_v, days_v, dur_v); Rcpp::ComplexVector res(getVectorLengths(months_v, days_v, dur_v)); if (res.size()) { const ConstPseudoVectorInt months(months_v); const ConstPseudoVectorInt days(days_v); const ConstPseudoVectorDbl dur(dur_v); for (R_xlen_t i=0; i(&dur[i]); period_union pu = { { months[i], days[i], dur_i } }; res[i] = Rcomplex{pu.dbl2.d1, pu.dbl2.d2 }; } } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::CharacterVector period_to_string_impl(Rcpp::ComplexVector prd) { Rcpp::CharacterVector res(prd.size()); for (R_xlen_t i=0; i(&prd[i]), sizeof(period)); if (pu.isNA()) { res[i] = NA_STRING; } else { res[i] = to_string(*reinterpret_cast(&pu)); } } if (prd.hasAttribute("names")) { Rcpp::CharacterVector prdnm(prd.names()); Rcpp::CharacterVector nm(prdnm.size()); for (R_xlen_t i=0; i dbl; // [[Rcpp::export]] Rcpp::ComplexVector period_from_integer64_impl(Rcpp::NumericVector i64) { Rcpp::ComplexVector res(i64.size()); for (R_xlen_t i=0; i(&i64[i]); if (elt == NA_INTEGER64) { period_union pu = { { NA_INTEGER, NA_INTEGER, NA_INTEGER64 } }; res[i] = Rcomplex{pu.dbl2.d1, pu.dbl2.d2 }; } else { period_union pu = { { 0, 0, elt } }; res[i] = Rcomplex{pu.dbl2.d1, pu.dbl2.d2 }; } } if (i64.hasAttribute("names")) { res.names() = i64.names(); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector period_from_integer_impl(Rcpp::IntegerVector iint) { Rcpp::ComplexVector res(iint.size()); for (R_xlen_t i=0; i(iint[i]) } }; res[i] = Rcomplex{pu.dbl2.d1, pu.dbl2.d2 }; } } if (iint.hasAttribute("names")) { res.names() = iint.names(); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector period_from_double_impl(Rcpp::NumericVector dbl) { Rcpp::ComplexVector res(dbl.size()); for (R_xlen_t i=0; i(dbl[i]) } }; res[i] = Rcomplex{pu.dbl2.d1, pu.dbl2.d2 }; } } if (dbl.hasAttribute("names")) { res.names() = dbl.names(); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector plus_period_period_impl(const Rcpp::ComplexVector e1_nv, const Rcpp::ComplexVector e2_nv) { checkVectorsLengths(e1_nv, e2_nv); Rcpp::ComplexVector res(getVectorLengths(e1_nv, e2_nv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_nv); const ConstPseudoVectorPrd e2_n(e2_nv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); period pu2; memcpy(&pu2, reinterpret_cast(&e2_n[i]), sizeof(period)); auto prd = pu1 + pu2; memcpy(&res[i], &prd, sizeof(prd)); } copyNames(e1_nv, e2_nv, res); } return assignS4("nanoperiod", res); } // unary '-' // [[Rcpp::export]] Rcpp::ComplexVector minus_period_impl(const Rcpp::ComplexVector e1_cv) { const ConstPseudoVectorPrd e1_n(e1_cv); Rcpp::ComplexVector res(e1_cv.size()); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); auto prd = -pu1; memcpy(&res[i], reinterpret_cast(&prd), sizeof(prd)); } copyNames(e1_cv, e1_cv, res); return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector minus_period_period_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::ComplexVector e2_cv) { checkVectorsLengths(e1_cv, e2_cv); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_cv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorPrd e2_n(e2_cv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); period pu2; memcpy(&pu2, reinterpret_cast(&e2_n[i]), sizeof(period)); auto prd = pu1 - pu2; memcpy(&res[i], reinterpret_cast(&prd), sizeof(prd)); } copyNames(e1_cv, e2_cv, res); } return assignS4("nanoperiod", res); } template Rcpp::LogicalVector compare_period_period(const Rcpp::ComplexVector e1_cv, const Rcpp::ComplexVector e2_cv, const OP& op) { checkVectorsLengths(e1_cv, e2_cv); Rcpp::LogicalVector res(getVectorLengths(e1_cv, e2_cv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorPrd e2_n(e2_cv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); period pu2; memcpy(&pu2, reinterpret_cast(&e2_n[i]), sizeof(period)); res[i] = op(pu1, pu2); } copyNames(e1_cv, e2_cv, res); } return res; } // [[Rcpp::export]] Rcpp::LogicalVector eq_period_period_impl(const Rcpp::ComplexVector e1_p, const Rcpp::ComplexVector e2_p) { return compare_period_period(e1_p, e2_p, std::equal_to()); } // [[Rcpp::export]] Rcpp::LogicalVector ne_period_period_impl(const Rcpp::ComplexVector e1_p, const Rcpp::ComplexVector e2_p) { return compare_period_period(e1_p, e2_p, std::not_equal_to()); } // [[Rcpp::export]] Rcpp::ComplexVector plus_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv) { checkVectorsLengths(e1_cv, e2_nv); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_nv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorInt64 e2_n(e2_nv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); duration dur; memcpy(&dur, reinterpret_cast(&e2_n[i]), sizeof(dur)); pu1 = plus(pu1, dur); memcpy(&res[i], &pu1, sizeof(pu1)); } copyNames(e1_cv, e2_nv, res); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector minus_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv) { checkVectorsLengths(e1_cv, e2_nv); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_nv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorInt64 e2_n(e2_nv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); duration dur; memcpy(&dur, reinterpret_cast(&e2_n[i]), sizeof(dur)); pu1 = minus(pu1, dur); memcpy(&res[i], &pu1, sizeof(pu1)); } copyNames(e1_cv, e2_nv, res); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector multiplies_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv) { checkVectorsLengths(e1_cv, e2_nv); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_nv)); const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorInt64 e2_n(e2_nv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); uint64_t m; memcpy(&m, reinterpret_cast(&e2_n[i]), sizeof(m)); pu1 = pu1 * m; memcpy(&res[i], &pu1, sizeof(pu1)); } copyNames(e1_cv, e2_nv, res); return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector divides_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv) { checkVectorsLengths(e1_cv, e2_nv); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_nv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorInt64 e2_n(e2_nv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); uint64_t m; memcpy(&m, reinterpret_cast(&e2_n[i]), sizeof(m)); pu1 = pu1 / m; memcpy(&res[i], &pu1, sizeof(pu1)); } copyNames(e1_cv, e2_nv, res); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector multiplies_period_double_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv) { checkVectorsLengths(e1_cv, e2_nv); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_nv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorDbl e2_n(e2_nv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); double m; memcpy(&m, reinterpret_cast(&e2_n[i]), sizeof(m)); pu1 = pu1 * m; memcpy(&res[i], &pu1, sizeof(pu1)); } copyNames(e1_cv, e2_nv, res); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector divides_period_double_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv) { checkVectorsLengths(e1_cv, e2_nv); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_nv)); if (res.size()) { const ConstPseudoVectorPrd e1_n(e1_cv); const ConstPseudoVectorDbl e2_n(e2_nv); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(period)); double m; memcpy(&m, reinterpret_cast(&e2_n[i]), sizeof(m)); pu1 = pu1 / m; memcpy(&res[i], &pu1, sizeof(pu1)); } copyNames(e1_cv, e2_nv, res); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector minus_integer64_period_impl(const Rcpp::NumericVector e1_nv, const Rcpp::ComplexVector e2_cv) { checkVectorsLengths(e1_nv, e2_cv); Rcpp::ComplexVector res(getVectorLengths(e1_nv, e2_cv)); if (res.size()) { const ConstPseudoVectorInt64 e1_n(e1_nv); const ConstPseudoVectorPrd e2_n(e2_cv); for (R_xlen_t i=0; i(&e2_n[i]), sizeof(pu2)); duration dur; memcpy(&dur, reinterpret_cast(&e1_n[i]), sizeof(dur)); pu2 = minus(dur, pu2); memcpy(&res[i], &pu2, sizeof(pu2)); } copyNames(e1_nv, e2_cv, res); } return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::NumericVector plus_nanotime_period_impl(const Rcpp::NumericVector e1_nv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(e1_nv, e2_cv, tz_v); Rcpp::ComplexVector res(getVectorLengths(e1_nv, e2_cv, tz_v)); if (res.size()) { const ConstPseudoVectorNano e1_n(e1_nv); const ConstPseudoVectorPrd e2_n(e2_cv); const ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(nano)); period prd; memcpy(&prd, reinterpret_cast(&e2_n[i]), sizeof(prd)); auto dt = plus(nano, prd, Rcpp::as(tz[i])); memcpy(&res[i], &dt, sizeof(dt)); } copyNames(e1_nv, e2_cv, res); } return assignS4("nanotime", res, "integer64"); } // [[Rcpp::export]] Rcpp::NumericVector minus_nanotime_period_impl(const Rcpp::NumericVector e1_nv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(e1_nv, e2_cv, tz_v); Rcpp::ComplexVector res(getVectorLengths(e1_nv, e2_cv, tz_v)); if (res.size()) { const ConstPseudoVectorNano e1_n(e1_nv); const ConstPseudoVectorPrd e2_n(e2_cv); const ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(nano)); period prd; memcpy(&prd, reinterpret_cast(&e2_n[i]), sizeof(prd)); auto dt = minus(nano, prd, Rcpp::as(tz[i % tz.size()])); memcpy(&res[i], &dt, sizeof(dt)); } copyNames(e1_nv, e2_cv, res); } return assignS4("nanotime", res, "integer64"); } // [[Rcpp::export]] Rcpp::ComplexVector plus_nanoival_period_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(e1_cv, e2_cv, tz_v); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_cv, tz_v)); if (res.size()) { const ConstPseudoVectorIval e1_n (e1_cv); const ConstPseudoVectorPrd e2_n (e2_cv); const ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(ival)); period prd; memcpy(&prd, reinterpret_cast(&e2_n[i]), sizeof(prd)); auto res_ival = plus(ival, prd, Rcpp::as(tz[i % tz.size()])); memcpy(&res[i], &res_ival, sizeof(res_ival)); } copyNames(e1_cv, e2_cv, res); } return assignS4("nanoival", res); } // [[Rcpp::export]] Rcpp::ComplexVector minus_nanoival_period_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v) { checkVectorsLengths(e1_cv, e2_cv, tz_v); Rcpp::ComplexVector res(getVectorLengths(e1_cv, e2_cv, tz_v)); if (res.size()) { const ConstPseudoVectorIval e1_n (e1_cv); const ConstPseudoVectorPrd e2_n (e2_cv); const ConstPseudoVectorChar tz(tz_v); for (R_xlen_t i=0; i(&e1_n[i]), sizeof(ival)); period prd; memcpy(&prd, reinterpret_cast(&e2_n[i]), sizeof(prd)); auto res_ival = minus(ival, prd, Rcpp::as(tz[i % tz.size()])); memcpy(&res[i], &res_ival, sizeof(res_ival)); } copyNames(e1_cv, e2_cv, res); } return assignS4("nanoival", res); } // [[Rcpp::export]] Rcpp::NumericVector period_month_impl(const Rcpp::ComplexVector e_n) { Rcpp::NumericVector res(e_n.size()); for (R_xlen_t i=0; i(&e_n[i]), sizeof(period)); if (prd.isNA()) { res[i] = NA_REAL; } else { res[i] = prd.getMonths(); } } if (e_n.hasAttribute("names")) { res.names() = e_n.names(); } return res; } // [[Rcpp::export]] Rcpp::NumericVector period_day_impl(const Rcpp::ComplexVector e_n) { Rcpp::NumericVector res(e_n.size()); for (R_xlen_t i=0; i(&e_n[i]), sizeof(period)); if (prd.isNA()) { res[i] = NA_REAL; } else { res[i] = prd.getDays(); } } if (e_n.hasAttribute("names")) { res.names() = e_n.names(); } return res; } // [[Rcpp::export]] Rcpp::S4 period_duration_impl(const Rcpp::ComplexVector e_n) { Rcpp::NumericVector res(e_n.size()); for (R_xlen_t i=0; i(&e_n[i]), sizeof(period)); if (prd.isNA()) { auto dur = duration::min(); memcpy(&res[i], &dur, sizeof(dur)); } else { auto dur = prd.getDuration(); memcpy(&res[i], &dur, sizeof(dur)); } } if (e_n.hasAttribute("names")) { res.names() = e_n.names(); } return assignS4("nanoduration", res, "integer64"); } // [[Rcpp::export]] Rcpp::LogicalVector period_isna_impl(const Rcpp::ComplexVector cv) { Rcpp::LogicalVector res(cv.size()); for (R_xlen_t i=0; i(&c), sizeof(c)); res[i] = prd.isNA(); } res.names() = cv.names(); return res; } constexpr duration abs(duration d) { return d >= d.zero() ? d : -d; } // This gives back a `nanotime` sequence for a `by` that is a `period`: // [[Rcpp::export]] Rcpp::NumericVector period_seq_from_to_impl(const Rcpp::NumericVector from_nv, const Rcpp::NumericVector to_nv, const Rcpp::ComplexVector by_cv, const std::string tz) { const ConstPseudoVectorNano from_n(from_nv); const ConstPseudoVectorNano to_n(to_nv); const ConstPseudoVectorPrd by_n(by_cv); dtime from; memcpy(&from, reinterpret_cast(&from_n[0]), sizeof(from)); dtime to; memcpy(&to, reinterpret_cast(&to_n[0]), sizeof(to)); period by; memcpy(&by, reinterpret_cast(&by_n[0]), sizeof(by)); std::vector res{from}; auto diff = to - from; auto pos = diff >= std::chrono::seconds(0); auto dist = abs(diff); auto olddist = dist; for (;;) { auto next = plus(res.back(), by, tz); if (pos ? next > to : next < to) break; res.push_back(next); olddist = dist; dist = abs(to - next); if (dist >= olddist) { Rcpp::stop("incorrect specification for 'to'/'by'"); // # nocov } } Rcpp::NumericVector res_rcpp(res.size()); memcpy(&res_rcpp[0], &res[0], sizeof(dtime)*res.size()); return assignS4("nanotime", res_rcpp, "integer64"); } // This gives back a `nanotime` sequence for a `by` that is a `period`: // [[Rcpp::export]] Rcpp::NumericVector period_seq_from_length_impl(const Rcpp::NumericVector from_nv, const Rcpp::ComplexVector by_cv, const Rcpp::NumericVector n_nv, const std::string tz) { const ConstPseudoVectorNano from_n(from_nv); const ConstPseudoVectorPrd by_n(by_cv); const ConstPseudoVectorNano n_n(n_nv); dtime from; memcpy(&from, reinterpret_cast(&from_n[0]), sizeof(from)); period by; memcpy(&by, reinterpret_cast(&by_n[0]), sizeof(by)); size_t n; memcpy(&n, reinterpret_cast(&n_n[0]), sizeof(n)); std::vector res{from}; for (size_t i=1; i::min(), std::numeric_limits::min(), duration::zero()); Rcomplex c; memcpy(&c, &p, sizeof(p)); return c; } // [[Rcpp::export]] Rcpp::ComplexVector period_subset_numeric_impl(const Rcpp::ComplexVector& v, const Rcpp::NumericVector& idx) { Rcpp::ComplexVector res(0); std::vector res_c; // by declaring it here we can make subset logical agnostic to 'Rcomplex' subset_numeric(v, idx, res, res_c, getNA_complex); return assignS4("nanoperiod", res); } // [[Rcpp::export]] Rcpp::ComplexVector period_subset_logical_impl(const Rcpp::ComplexVector& v, const Rcpp::LogicalVector& idx_p) { const ConstPseudoVectorBool idx(idx_p); Rcpp::ComplexVector res(0); std::vector res_c; // by declaring it here we can make subset logical agnostic to 'Rcomplex' subset_logical(v, idx, res, res_c, getNA_complex); return assignS4("nanoperiod", res); } nanotime/src/strnlen.cpp0000644000176200001440000000034113713656775015066 0ustar liggesusers // SunOS has no strnlen #include namespace nanotime { size_t strnlen_(const char *s, size_t maxlen) { size_t len; for (len = 0; len < maxlen; len++, s++) { if (!*s) break; } return (len); } } nanotime/src/duration.cpp0000644000176200001440000001443113703333711015210 0ustar liggesusers#include #include #include #include #include #include #include #include #include #include "nanotime/duration.hpp" #include "nanotime/pseudovector.hpp" #include "nanotime/utilities.hpp" using namespace nanotime; duration nanotime::from_string(const std::string& str) { duration d = std::chrono::seconds(0); const char* s = str.c_str(); const char* e = s + str.size(); auto sign = 1; if (s < e && *s == '-') { sign = -1; ++s; } int n; if (!readNumber(s, e, n, false)) throw std::range_error("cannot parse nanoduration"); if (s < e && *s == ':') { // we've got HHH:MM:SS format d += n * std::chrono::hours(1); ++s; if (s + 5 > e || !isdigit(s[0]) || !isdigit(s[1]) || s[2] != ':' || !isdigit(s[3]) || !isdigit(s[4])) { throw std::range_error("cannot parse nanoduration"); } d += ((s[0] - '0')*10 + (s[1] - '0'))*std::chrono::minutes(1); // treat seconds in the general way: n = (s[3] - '0')*10 + (s[4] - '0'); s += 5; } d += n * std::chrono::seconds(1); if (s == e) return sign*d; if (*s++ != '.') throw std::range_error("cannot parse nanoduration"); duration mul = std::chrono::milliseconds(100); unsigned i = 0; while (s < e) { if (mul < std::chrono::nanoseconds(1)) throw std::range_error("cannot parse nanoduration"); if ((i == 3 || i == 6) && *s == '_') { ++s; continue; } ++i; if (!isdigit(*s)) throw std::range_error("cannot parse nanoduration"); d += (*s - '0') * mul; mul /= 10; ++s; } return sign*d; } std::string nanotime::to_string(duration d) { std::stringstream ss; if (is_na(d)) { ss << ""; } else { // handle hh:mm:ss if (d < std::chrono::seconds(0)) { ss << '-'; d *= -1; } auto h = d / std::chrono::hours(1); d -= h * std::chrono::seconds(3600); auto min = d / std::chrono::minutes(1); d -= min * std::chrono::seconds(60); auto s = d / std::chrono::seconds(1); d -= s * std::chrono::seconds(1); ss << std::setfill ('0') << std::setw(2) << h << ':' << std::setw(2) << min << ':' << std::setw(2) << s; // now handle nanoseconds 000_000_000 auto ms = d / std::chrono::milliseconds(1); d -= ms * std::chrono::milliseconds(1); auto us = d / std::chrono::microseconds(1); d -= us * std::chrono::microseconds(1); auto ns = d / std::chrono::nanoseconds(1); d -= ns * std::chrono::nanoseconds(1); if (ms || us || ns) { ss << '.'; ss << std::setfill ('0') << std::setw(3) << ms; if (us || ns) { ss << '_' << std::setfill('0') << std::setw(3) << us; if (ns) { ss << '_' << std::setfill('0') << std::setw(3) << ns; } } } } return ss.str(); } bool nanotime::is_na(duration d) { return d == duration::min(); } // [[Rcpp::export]] Rcpp::NumericVector duration_from_string_impl(Rcpp::CharacterVector str) { Rcpp::NumericVector res(str.size()); for (R_xlen_t i=0; i(str[i])); double* ptr = reinterpret_cast(&dur); res[i] = *ptr; } if (str.hasAttribute("names")) { res.names() = str.names(); } return assignS4("nanoduration", res, "integer64"); } // [[Rcpp::export]] Rcpp::CharacterVector duration_to_string_impl(Rcpp::NumericVector dur) { Rcpp::CharacterVector res(dur.size()); for (R_xlen_t i=0; i(&dur[i]); res[i] = to_string(*dur_i); if (res[i].size() == 0) { res[i] = NA_STRING; } } if (dur.hasAttribute("names")) { res.names() = dur.names(); } return res; } // [[Rcpp::export]] Rcpp::LogicalVector duration_is_na_impl(Rcpp::NumericVector dur) { Rcpp::LogicalVector res(dur.size()); for (R_xlen_t i=0; i(&dur[i]); res[i] = is_na(*dur_i); } if (dur.hasAttribute("names")) { res.names() = dur.names(); } return res; } typedef ConstPseudoVector ConstPseudoVectorInt64; typedef ConstPseudoVector ConstPseudoVectorLgl; // [[Rcpp::export]] Rcpp::NumericVector make_duration_impl(const Rcpp::NumericVector h_nv, const Rcpp::NumericVector m_nv, const Rcpp::NumericVector s_nv, const Rcpp::NumericVector n_nv) { const ConstPseudoVectorInt64 h_i(h_nv); const ConstPseudoVectorInt64 m_i(m_nv); const ConstPseudoVectorInt64 s_i(s_nv); const ConstPseudoVectorInt64 n_i(n_nv); Rcpp::NumericVector res(std::max(std::max(h_i.size(), m_i.size()), std::max(s_i.size(), n_i.size()))); for (R_xlen_t i=0; i(&h_i[i]); auto m64 = *reinterpret_cast(&m_i[i]); auto s64 = *reinterpret_cast(&s_i[i]); auto n64 = *reinterpret_cast(&n_i[i]); auto dur = (h64*3600 + m64*60 + s64) * 1000000000L + n64; double *ptr = reinterpret_cast(&dur); res[i] = *ptr; } return assignS4("nanoduration", res, "integer64"); } static double getNA_nanoduration() { const int64_t i64 = std::numeric_limits::min(); double res; memcpy(&res, &i64, sizeof(res)); return res; } // [[Rcpp::export]] Rcpp::NumericVector nanoduration_subset_numeric_impl(const Rcpp::NumericVector& v, const Rcpp::NumericVector& idx) { Rcpp::NumericVector res(0); std::vector res_c; // by declaring it here we can make subset logical agnostic to double subset_numeric(v, idx, res, res_c, getNA_nanoduration); return assignS4("nanoduration", res, "integer64"); } // [[Rcpp::export]] Rcpp::NumericVector nanoduration_subset_logical_impl(const Rcpp::NumericVector& v, const Rcpp::LogicalVector& idx_p) { const ConstPseudoVectorLgl idx(idx_p); Rcpp::NumericVector res(0); std::vector res_c; // by declaring it here we can make subset logical agnostic to double subset_logical(v, idx, res, res_c, getNA_nanoduration); return assignS4("nanoduration", res, "integer64"); } nanotime/src/Makevars0000644000176200001440000000022513636243601014352 0ustar liggesusers## We want C++11 CXX_STD = CXX11 ## We need headers from our package, the directory is not automatically included PKG_CXXFLAGS = -I../inst/include nanotime/src/Makevars.win0000644000176200001440000000024713710363601015146 0ustar liggesusers## We want C++11 CXX_STD = CXX11 ## We need headers from our package, the directory is not automatically included PKG_CXXFLAGS = -I../inst/include -mno-ms-bitfields nanotime/src/Makevars.ucrt0000644000176200001440000000030614154510261015321 0ustar liggesusers## We want C++11 CXX_STD = CXX11 ## We need headers from our package, the directory is not automatically included PKG_CXXFLAGS = -I../inst/include -mno-ms-bitfields -D_POSIX_THREAD_SAFE_FUNCTIONS nanotime/src/interval.cpp0000644000176200001440000006607613723317114015224 0ustar liggesusers#include #include #include #include #include "nanotime/interval.hpp" #include "nanotime/pseudovector.hpp" #include "nanotime/utilities.hpp" #include "cctz/civil_time.h" #include "cctz/time_zone.h" using namespace nanotime; struct double2 { double d1; double d2; }; union ival_union { struct ival_alias { bool sopen : 1; int64_t s : 63; bool eopen : 1; int64_t e : 63; } ival; double2 dbl2; }; typedef ConstPseudoVector ConstPseudoVectorIval; typedef ConstPseudoVector ConstPseudoVectorDur; typedef ConstPseudoVector ConstPseudoVectorNum; typedef ConstPseudoVector ConstPseudoVectorLgl; typedef ConstPseudoVector ConstPseudoVectorChar; // for debug reasons... // the following code from: https://stackoverflow.com/a/16692519 template std::ostream &operator<<(std::ostream &stream, const std::chrono::time_point &time_point) { const time_t time = Clock::to_time_t(time_point); #if __GNUC__ > 4 || \ ((__GNUC__ == 4) && __GNUC_MINOR__ > 8 && __GNUC_REVISION__ > 1) // Maybe the put_time will be implemented later? struct tm tm; localtime_r(&time, &tm); return stream << std::put_time(&tm, "%c"); // Print standard date&time #else char buffer[26]; ctime_r(&time, buffer); buffer[24] = '\0'; // Removes the newline that is added return stream << buffer; #endif } #if 0 static void print(const interval& i) { Rcpp::Rcout << (i.sopen ? "-" : "+") << i.s << "->" << i.e << (i.eopen ? "-" : "+") << std::endl; } #endif template static Rcpp::List intersect_idx(const T* v1, size_t v1_size, const U* v2, size_t v2_size) { // because 'push_back' on R structures is crazy expensive, we use STL vector and copy afterwards: std::vector res_first; std::vector res_second; size_t i1 = 0, i2 = 0; while (i1 < v1_size && i2 < v2_size) { if (v1[i1] < v2[i2]) { ++i1; } else if (v1[i1] > v2[i2]) { ++i2; } else { if (v1_size==0 || v1[i1] != v1[i1-1]) { res_first.push_back(i1+1); res_second.push_back(i2+1); } ++i1; //++i2; this is correct for T==U, but not for example when //T==time and U==interval } } // copy out result: Rcpp::NumericVector res_first_rcpp(res_first.size()); Rcpp::NumericVector res_second_rcpp(res_second.size()); if (res_first.size() > 0) memcpy(&res_first_rcpp[0], &res_first[0], sizeof(double)*res_first.size()); if (res_second.size() > 0) memcpy(&res_second_rcpp[0], &res_second[0], sizeof(double)*res_second.size()); return Rcpp::List::create(Rcpp::Named("x") = res_first_rcpp, Rcpp::Named("y") = res_second_rcpp); } // do a fast intersect without caring about the second index, and // return the result as boolean; this is useful for `data.table` // subsetting: template static std::vector intersect_idx_logical(const T* v1, size_t v1_size, const U* v2, size_t v2_size) { std::vector res(v1_size); size_t i1 = 0, i2 = 0; while (i1 < v1_size && i2 < v2_size) { if (v1[i1] < v2[i2]) { res[i1] = FALSE; ++i1; } else if (v1[i1] > v2[i2]) { ++i2; } else { if (v1_size==0 || v1[i1] != v1[i1-1]) { res[i1] = TRUE; } ++i1; } } return res; } /// intersect_idx T=dtime, U=dtime doesn't need specialization. /// intersect_idx T=dtime, U=tz::interval doesn't need specialization. /// intersect_idx interval/interval doesn't make sense. // RcppExport SEXP _intersect_idx_time_time(SEXP sv1, SEXP sv2) // { // const Rcpp::NumericVector nv1(sv1); // const Rcpp::NumericVector nv2(sv2); // const size_t v1_size = nv1.size(); // const size_t v2_size = nv2.size(); // const dtime* v1 = reinterpret_cast(&nv1[0]); // const dtime* v2 = reinterpret_cast(&nv2[0]); // return intersect_idx(v1, v1_size, v2, v2_size); // } // [[Rcpp::export]] Rcpp::List nanoival_intersect_idx_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2) { const dtime* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&nv2[0]); return intersect_idx(v1, nv1.size(), v2, nv2.size()); } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_intersect_idx_time_interval_logical_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2) { const dtime* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&nv2[0]); auto res_c = intersect_idx_logical(v1, nv1.size(), v2, nv2.size()); Rcpp::LogicalVector res(nv1.size()); if (nv1.size() > 0) memcpy(&res[0], &res_c[0], sizeof(int)*nv1.size()); return res; } // [[Rcpp::export]] Rcpp::S4 nanoival_intersect_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2) { std::vector res; const dtime* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&nv2[0]); R_xlen_t i1 = 0, i2 = 0; while (i1 < nv1.size() && i2 < nv2.size()) { if (v1[i1] < v2[i2]) { ++i1; } else if (v1[i1] > v2[i2]) { ++i2; } else { if (res.size()==0 || v1[i1] != res.back()) { res.push_back(v1[i1]); } ++i1; } } if (res.size() > 0) { double* res_start = reinterpret_cast(&res[0]); double* res_end = res_start + res.size(); auto final_res = Rcpp::NumericVector(res_start, res_end); return assignS4("nanotime", final_res, "integer64"); } else { auto final_res = Rcpp::NumericVector(0); return assignS4("nanotime", final_res, "integer64"); } } // [[Rcpp::export]] Rcpp::NumericVector nanoival_setdiff_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2) { std::vector res; const dtime* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&nv2[0]); R_xlen_t i1 = 0, i2 = 0; while (i1 < nv1.size() && i2 < nv2.size()) { if (v1[i1] < v2[i2]) { res.push_back(v1[i1++]); } else if (v1[i1] > v2[i2]) { ++i2; } else { ++i1; } } // pick up elts left in v1: while (i1 < nv1.size()) { res.push_back(v1[i1++]); } double* res_start = reinterpret_cast(&res[0]); double* res_end = res_start + res.size(); return Rcpp::NumericVector(res_start, res_end); } // [[Rcpp::export]] Rcpp::ComplexVector nanoival_union_impl(const Rcpp::ComplexVector nv1, const Rcpp::ComplexVector nv2) { // assume 'nanoival1/2' were sorted at the R level std::vector res; const interval* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&nv2[0]); R_xlen_t i1 = 0, i2 = 0; if (nv1.size() > 0 && nv2.size() > 0) { auto v1_lt_v2 = start_lt(v1[i1], v2[i2]); auto start = v1_lt_v2 ? v1[i1].getStart() : v2[i2].getStart(); auto sopen = v1_lt_v2 ? v1[i1].sopen : v2[i2].sopen; for (;;) { if (union_end_ge_start(v1[i1], v2[i2]) && union_end_le(v1[i1], v2[i2])) { // v1 |------------| or |--------| // v2 |------------| |------------| if (i1 >= nv1.size() - 1) { // if equal ends, have to do the union of the eopens: auto eopen = union_end_le(v2[i2], v1[i1]) ? v1[i1].eopen && v2[i2].eopen : v2[i2].eopen; // v2 interval done, as there's no more v1 elts to overlap res.push_back(interval(start, v2[i2].getEnd(), sopen, eopen)); ++i1; ++i2; break; } ++i1; } else if (union_end_ge_start(v2[i2], v1[i1]) && union_end_le(v2[i2], v1[i1])) { // v1 |------------| or |------------| // v2 |------------| |--------| if (i2 >= nv2.size() - 1) { // if equal ends, have to do the union of the eopens: auto eopen = union_end_le(v1[i1], v2[i2]) ? v1[i1].eopen && v2[i2].eopen : v1[i1].eopen; // v1 interval done, as there's no more v2 elts to overlap res.push_back(interval(start, v1[i1].getEnd(), sopen, eopen)); ++i1; ++i2; break; } ++i2; } else { if (v1[i1].getEnd() == v2[i2].getEnd() && v1[i1].eopen && v2[i2].eopen) { // special case where the intervals are ends are equal and open: res.push_back(interval(start, v1[i1].getEnd(), sopen, v1[i1].eopen)); ++i1; ++i2; } else if (union_end_lt(v1[i1], v2[i2])) { // no interval overlap res.push_back(interval(start, v1[i1].getEnd(), sopen, v1[i1].eopen)); ++i1; } else { // no interval overlap res.push_back(interval(start, v2[i2].getEnd(), sopen, v2[i2].eopen)); ++i2; } // set the start of the next interval: if (i1 < nv1.size() && i2 < nv2.size()) { auto v1_lt_v2 = start_lt(v1[i1], v2[i2]); start = v1_lt_v2 ? v1[i1].getStart() : v2[i2].getStart(); sopen = v1_lt_v2 ? v1[i1].sopen : v2[i2].sopen; } else { break; } } } } // remaining non-overlapping intervals in v1: while (i1 < nv1.size()) { res.push_back(v1[i1++]); } while (i2 < nv2.size()) { res.push_back(v2[i2++]); } // build the ComplexVector that we will return to R: Rcpp::ComplexVector finalres(res.size()); memcpy(&finalres[0], &res[0], sizeof(Rcomplex)*res.size()); return finalres; } // [[Rcpp::export]] Rcpp::ComplexVector nanoival_intersect_impl(const Rcpp::ComplexVector nv1, const Rcpp::ComplexVector nv2) { // assume 'nanoival1/2' were sorted at the R level std::vector res; const interval* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&nv2[0]); R_xlen_t i1 = 0, i2 = 0; while (i1 < nv1.size() && i2 < nv2.size()) { if (v1[i1].getEnd() < v2[i2].getStart() || (v1[i1].getEnd() == v2[i2].getStart() && (v1[i1].eopen || v2[i2].sopen))) { ++i1; continue; } else if (v2[i2].getEnd() < v1[i1].getStart() || (v2[i2].getEnd() == v1[i1].getStart() && (v1[i1].sopen || v2[i2].eopen))) { ++i2; continue; } else { auto v1_gt_v2 = start_gt(v1[i1], v2[i2]); auto start = v1_gt_v2 ? v1[i1].getStart() : v2[i2].getStart(); auto sopen = v1_gt_v2 ? v1[i1].sopen : v2[i2].sopen; if (end_lt(v1[i1], v2[i2])) { res.push_back(interval(start, v1[i1].getEnd(), sopen, v1[i1].eopen)); ++i1; } else { res.push_back(interval(start, v2[i2].getEnd(), sopen, v2[i2].eopen)); ++i2; } } } // build the ComplexVector that we will return to R: Rcpp::ComplexVector finalres(res.size()); if (res.size() > 0) memcpy(&finalres[0], &res[0], sizeof(Rcomplex)*res.size()); return assignS4("nanoival", finalres); } // [[Rcpp::export]] Rcpp::ComplexVector nanoival_setdiff_impl(const Rcpp::ComplexVector nv1, const Rcpp::ComplexVector nv2) { // assume 'nanoival1/2' were sorted at the R level std::vector res; const interval* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&nv2[0]); R_xlen_t i1 = 0, i2 = 0; auto start = v1[i1].getStart(); auto sopen = v1[i1].sopen; while (i1 < nv1.size() && i2 < nv2.size()) { if (end_lt_start(v1[i1], v2[i2])) { // |-------------| // |------------| res.push_back(interval(start, v1[i1].getEnd(), sopen, v1[i1].eopen)); if (++i1 >= nv1.size()) break; start = v1[i1].getStart(); sopen = v1[i1].sopen; } else if (start_lt(v2[i2].getEnd(), v2[i2].eopen, start, sopen)) { // |------------| // |-------------| ++i2; } else if (start_lt(start, sopen, v2[i2].getStart(), v2[i2].sopen)) { // |-------------| or |-------------| // |------------| |-------| res.push_back(interval(start, v2[i2].getStart(), sopen, !v2[i2].sopen)); if (end_gt(v1[i1], v2[i2])) { // |-------------| // |-------| start = v2[i2].getEnd(); sopen = !v2[i2].eopen; ++i2; } else { // |-------------| // |------------| if (++i1 >= nv1.size()) break; start = v1[i1].getStart(); sopen = v1[i1].sopen; } } else if (start_ge(start, sopen, v2[i2].getStart(), v2[i2].sopen) && end_ge(v2[i2], v1[i1])) { // |-------| // |-------------| if (++i1 >= nv1.size()) break; start = v1[i1].getStart(); sopen = v1[i1].sopen; } else { // |------------| // |----------| start = v2[i2].getEnd(); sopen = !v2[i2].eopen; ++i2; } } // remaining non-overlapping intervals in v1: if (i1 < nv1.size()) { res.push_back(interval(start, v1[i1].getEnd(), sopen, v1[i1].eopen)); ++i1; while (i1 < nv1.size()) { res.push_back(v1[i1++]); } } // build the ComplexVector that we will return to R: Rcpp::ComplexVector finalres(res.size()); if (res.size() > 0) memcpy(&finalres[0], &res[0], sizeof(Rcomplex)*res.size()); return finalres; } // [[Rcpp::export]] bool nanoival_is_unsorted_impl(const Rcpp::ComplexVector nvec, const Rcpp::LogicalVector strictlyvec) { if (strictlyvec.size() == 0) { Rcpp::stop("argument 'strictly' cannot have length 0"); } const bool strictlybool = strictlyvec[0]; const interval* ival_ptr = reinterpret_cast(&nvec[0]); const auto ival_len = nvec.size(); if (strictlybool) { for (R_xlen_t i=1; i= ival_ptr[i]) { return true; } } } else { for (R_xlen_t i=1; i ival_ptr[i]) { return true; } } } return false; } // [[Rcpp::export]] const Rcpp::ComplexVector nanoival_sort_impl(const Rcpp::ComplexVector nvec, const Rcpp::LogicalVector decreasingvec) { Rcpp::ComplexVector res = clone(nvec); interval* ival_ptr = reinterpret_cast(&res[0]); const auto ival_len = res.size(); interval* start = ival_ptr; interval* end = start + ival_len; if (decreasingvec.size() == 0) { Rcpp::stop("argument 'decreasing' cannot have length 0"); } else if (!decreasingvec[0]) { std::sort(start, end); } else { std::sort(start, end, std::greater()); } return res; } // [[Rcpp::export]] const Rcpp::ComplexVector nanoival_sort_impl2(const Rcpp::ComplexVector nvec, // #nocov start bool decreasing) { Rcpp::ComplexVector res = clone(nvec); interval* ival_ptr = reinterpret_cast(&res[0]); const auto ival_len = res.size(); interval* start = ival_ptr; interval* end = start + ival_len; if (!decreasing) { std::sort(start, end); } else { std::sort(start, end, std::greater()); } return res; } // #nocov end template Rcpp::LogicalVector nanoival_comp(const Rcpp::ComplexVector v1, const Rcpp::ComplexVector v2, COMP cmp) { checkVectorsLengths(v1, v2); Rcpp::LogicalVector res(getVectorLengths(v1, v2)); if (res.size()) { const ConstPseudoVectorIval cv1(v1); const ConstPseudoVectorIval cv2(v2); const interval* n1_ptr = reinterpret_cast(&cv1[0]); const interval* n2_ptr = reinterpret_cast(&cv2[0]); for (R_xlen_t i=0; i()); } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_le_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2) { return nanoival_comp(n1, n2, std::less_equal()); } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_gt_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2) { return nanoival_comp(n1, n2, std::greater()); } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_ge_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2) { return nanoival_comp(n1, n2, std::greater_equal()); } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_eq_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2) { return nanoival_comp(n1, n2, std::equal_to()); } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_ne_impl(Rcpp::ComplexVector n1, Rcpp::ComplexVector n2) { return nanoival_comp(n1, n2, std::not_equal_to()); } template Rcpp::ComplexVector nanoival_op(const Rcpp::ComplexVector cv1, const Rcpp::NumericVector nv2, OP op) { checkVectorsLengths(cv1, nv2); Rcpp::ComplexVector res(getVectorLengths(cv1, nv2)); if (res.size()) { const ConstPseudoVectorIval e1(cv1); const ConstPseudoVectorDur e2(nv2); for (R_xlen_t i=0; i(&e1[i]); const duration dur = *reinterpret_cast(&e2[i]); const auto ires = op(ival, dur); const Rcomplex *ptr = reinterpret_cast(&ires); res[i] = *ptr; } copyNames(cv1, nv2, res); } return res; } // [[Rcpp::export]] Rcpp::ComplexVector nanoival_plus_impl(const Rcpp::ComplexVector n1, const Rcpp::NumericVector n2) { return nanoival_op(n1, n2, nanotime_ops::plus()); } // [[Rcpp::export]] Rcpp::ComplexVector nanoival_minus_impl(const Rcpp::ComplexVector n1, const Rcpp::NumericVector n2) { return nanoival_op(n1, n2, nanotime_ops::minus()); } /// union_idx T=dtime, U=dtime doesn't need specialization. /// union_idx T=dtime, U=tz::interval doesn't make sense. /// union_idx interval/interval doesn't make sense. /// setdiff_idx T=dtime, U=dtime doesn't need specialization. /// setdiff_idx T=interval, U=interval doesn't make sense /// setdiff_idx T=dtime, U=interval: template static Rcpp::NumericVector setdiff_idx(const T* v1, size_t v1_size, const U* v2, size_t v2_size) { std::vector res_first; size_t i1 = 0, i2 = 0; while (i1 < v1_size && i2 < v2_size) { if (v1[i1] < v2[i2]) { res_first.push_back(i1+1); ++i1; } else if (v1[i1] > v2[i2]) { ++i2; } else { ++i1; } } // pick up elts left in v1: while (i1 < v1_size) { res_first.push_back(i1+1); ++i1; } // copy out result: Rcpp::NumericVector res_first_rcpp(res_first.size()); if (res_first.size() > 0) memcpy(&res_first_rcpp[0], &res_first[0], sizeof(double)*res_first.size()); return res_first_rcpp; } // [[Rcpp::export]] Rcpp::NumericVector nanoival_setdiff_idx_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector cv2) { const dtime* v1 = reinterpret_cast(&nv1[0]); const interval* v2 = reinterpret_cast(&cv2[0]); return setdiff_idx(v1, nv1.size(), v2, cv2.size()); } // [[Rcpp::export]] Rcpp::S4 nanoival_new_impl(const Rcpp::NumericVector sv, const Rcpp::NumericVector ev, const Rcpp::LogicalVector sopenv, const Rcpp::LogicalVector eopenv) { // handle the special case where one of the operands has 0-length: Rcpp::ComplexVector res(getVectorLengths(sv, ev, sopenv, eopenv)); checkVectorsLengths(sv, ev, sopenv, eopenv); const ConstPseudoVectorNum nvs(sv); const ConstPseudoVectorNum nve(ev); const ConstPseudoVectorLgl lvs(sopenv); const ConstPseudoVectorLgl lve(eopenv); for (R_xlen_t i=0; i < res.size(); ++i) { const double d1 = nvs[i]; const double d2 = nve[i]; dtime i1, i2; memcpy(&i1, reinterpret_cast(&d1), sizeof(d1)); memcpy(&i2, reinterpret_cast(&d2), sizeof(d2)); const interval ival { i1, i2, lvs[i], lve[i] }; memcpy(&res[i], &ival, sizeof(ival)); } return assignS4("nanoival", res); } // R accessor functions: // [[Rcpp::export]] Rcpp::NumericVector nanoival_get_start_impl(const Rcpp::ComplexVector cv) { Rcpp::NumericVector res(cv.size()); for (R_xlen_t i=0; i(&c), sizeof(c)); if (ival.isNA()) { double d; memcpy(&d, reinterpret_cast(&NA_INTEGER64), sizeof(NA_INTEGER64)); res[i] = d; } else { std::int64_t start = ival.s; double d; memcpy(&d, reinterpret_cast(&start), sizeof(start)); res[i] = d; } } res.names() = cv.names(); return assignS4("nanotime", res, "integer64"); } // [[Rcpp::export]] Rcpp::NumericVector nanoival_get_end_impl(const Rcpp::ComplexVector cv) { Rcpp::NumericVector res(cv.size()); for (R_xlen_t i=0; i(&c), sizeof(c)); if (ival.isNA()) { double d; memcpy(&d, reinterpret_cast(&NA_INTEGER64), sizeof(NA_INTEGER64)); res[i] = d; } else { std::int64_t end = ival.e; double d; memcpy(&d, reinterpret_cast(&end), sizeof(end)); res[i] = d; } } res.names() = cv.names(); return assignS4("nanotime", res, "integer64"); } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_get_sopen_impl(const Rcpp::ComplexVector cv) { Rcpp::LogicalVector res(cv.size()); for (R_xlen_t i=0; i(&c), sizeof(c)); if (ival.isNA()) { res[i] = NA_LOGICAL; } else { res[i] = ival.sopen; } } res.names() = cv.names(); return res; } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_get_eopen_impl(const Rcpp::ComplexVector cv) { Rcpp::LogicalVector res(cv.size()); for (R_xlen_t i=0; i(&c), sizeof(c)); if (ival.isNA()) { res[i] = NA_LOGICAL; } else { res[i] = ival.eopen; } } res.names() = cv.names(); return res; } // [[Rcpp::export]] Rcpp::LogicalVector nanoival_isna_impl(const Rcpp::ComplexVector cv) { Rcpp::LogicalVector res(cv.size()); for (R_xlen_t i=0; i(&c), sizeof(c)); res[i] = ival.isNA(); } res.names() = cv.names(); return res; } static Rcomplex readNanoival(const char*& sp, const char* const se, const char* tzstr) { // read the +- at the beginning: if (sp >= se || (*sp != '+' && *sp != '-')) { throw std::range_error("Error parsing"); } auto sopen = *sp++ == '+' ? false : true; auto ss = readDtime(sp, se); if (ss.tzstr.size() && strnlen_(tzstr, MAX_TZ_STR_LENGTH)) { throw std::range_error("timezone is specified twice: in the string and as an argument"); } skipWhitespace(sp, se); // read the middle portion if (sp+2 >= se || (*sp != '-' && *(sp+1) != '>')) { throw std::range_error("Error parsing"); } sp += 2; skipWhitespace(sp, se); auto es = readDtime(sp, se-1); // -1 because we don't want to read the -+ as a timezone if (es.tzstr.size() && strnlen_(tzstr, MAX_TZ_STR_LENGTH)) { throw std::range_error("timezone is specified twice: in the string and as an argument"); // ## nocov } // read the +- at the end: if (sp >= se || (*sp != '+' && *sp != '-')) { throw std::range_error("Error parsing aa"); } auto eopen = *sp++ == '+' ? false : true; // check we read until the end if (sp != se) { throw std::range_error("Error parsing"); } const cctz::civil_second start_cvt(ss.y, ss.m, ss.d, ss.hh, ss.mm, ss.ss); cctz::time_point start_tp; const char* tzstr_start = ss.tzstr.size() ? ss.tzstr.c_str() : tzstr; int cvt_res = RcppCCTZ::convertToTimePoint(start_cvt, tzstr_start, start_tp); if (cvt_res < 0) { Rcpp::stop("Cannot retrieve timezone '%s'.", tzstr_start); // ## nocov } auto start = dtime{std::chrono::nanoseconds((start_tp.time_since_epoch().count() - ss.offset) * 1000000000ll + ss.ns)}; const cctz::civil_second end_cvt(es.y, es.m, es.d, es.hh, es.mm, es.ss); cctz::time_point end_tp; const char* tzstr_end = es.tzstr.size() ? es.tzstr.c_str() : tzstr; cvt_res = RcppCCTZ::convertToTimePoint(end_cvt, tzstr_end, end_tp); if (cvt_res < 0) { Rcpp::stop("Cannot retrieve timezone '%s'.", tzstr_end); } auto end = dtime{std::chrono::nanoseconds((end_tp.time_since_epoch().count() - es.offset) * 1000000000ll + es.ns)}; Rcomplex res; const interval ival { start, end, sopen, eopen }; memcpy(&res, &ival, sizeof(ival)); return res; } // [[Rcpp::export]] Rcpp::ComplexVector nanoival_make_impl(const Rcpp::CharacterVector nt_v, const Rcpp::CharacterVector tz_v) { // handle the special case where one of the operands has 0-length: if (nt_v.size() == 0 || tz_v.size() == 0) { Rcpp::ComplexVector res(0); return assignS4("nanoival", res); } checkVectorsLengths(nt_v, tz_v); ConstPseudoVectorChar nt(nt_v); ConstPseudoVectorChar tz(tz_v); Rcpp::ComplexVector res(nt.size()); for (R_xlen_t i=0; i res_c; // by declaring it here we can make subset logical agnostic to 'Rcomplex' subset_numeric(v, idx, res, res_c, getNA_ival); return assignS4("nanoival", res); } // [[Rcpp::export]] Rcpp::ComplexVector nanoival_subset_logical_impl(const Rcpp::ComplexVector& v, const Rcpp::LogicalVector& idx_p) { const ConstPseudoVectorLgl idx(idx_p); Rcpp::ComplexVector res(0); std::vector res_c; subset_logical(v, idx, res, res_c, getNA_ival); return assignS4("nanoival", res); } nanotime/src/rounding.cpp0000644000176200001440000003240714146544040015214 0ustar liggesusers#include #include #include "nanotime/period.hpp" #include "nanotime/utilities.hpp" using namespace nanotime; // C++-level floor and ceiling functions: // support for rounding 'dtime': enum class RoundingPrecision : uint64_t { NANO, MICRO, MILLI, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, YEAR }; static bool isMultipleOf(duration d1, duration d2) { if (d2.count() % d1.count() == 0) { // d1 strictly positive return true; } else { return false; } } static bool isMultipleOf(const period& p1, const period& p2) { // the multiple is considered at the month level, the day level and the duration level; // we know going in here that p2 was artifically generated to have only one of the three portions non-zero: if (p1.getMonths()) { if (p2.getMonths() && !p2.getDays() && p2.getDuration() == duration::zero()) { return p2.getMonths() % p1.getMonths() == 0; } } else if (p1.getDays()) { // for function completeness as we never execute this branch in this setting: #nocov start if (!p2.getMonths() && p2.getDays() && p2.getDuration() == duration::zero()) { return p2.getDays() % p1.getDays() == 0; } } else if (p1.getDuration() != duration::zero()) { // for function completeness as we never execute this branch in this setting if (!p2.getMonths() && !p2.getDays() && p2.getDuration() == duration::zero()) { return isMultipleOf(p1.getDuration(), p2.getDuration()); } } return false; // for function completeness as we never execute this branch in this setting #nocov end } static RoundingPrecision selectPrecision(const duration d) { if (d < std::chrono::microseconds{1}) return isMultipleOf(d, std::chrono::microseconds{1}) ? RoundingPrecision::MICRO : RoundingPrecision::NANO; else if (d < std::chrono::milliseconds{1}) return isMultipleOf(d, std::chrono::milliseconds{1}) ? RoundingPrecision::MILLI : RoundingPrecision::MICRO; else if (d < std::chrono::seconds{1}) return isMultipleOf(d, std::chrono::seconds{1}) ? RoundingPrecision::SECOND : RoundingPrecision::MILLI; else if (d < std::chrono::minutes{1}) return isMultipleOf(d, std::chrono::minutes{1}) ? RoundingPrecision::MINUTE : RoundingPrecision::SECOND; else if (d < std::chrono::hours{1}) return isMultipleOf(d, std::chrono::hours{1}) ? RoundingPrecision::HOUR : RoundingPrecision::MINUTE; else return RoundingPrecision::HOUR; } static RoundingPrecision selectPrecision(const period p) { const auto year = period(12, 0, duration::zero()); if (p.getMonths() >= 1) return isMultipleOf(p, year) ? RoundingPrecision::YEAR : RoundingPrecision::MONTH; else if (p.getDays() >= 1) return RoundingPrecision::DAY; else if (p.getDuration() >= std::chrono::hours{1}) return (isMultipleOf(p.getDuration(), std::chrono::hours{24})) ? RoundingPrecision::DAY : selectPrecision(p.getDuration()); else return selectPrecision(p.getDuration()); } static dtime floor(dtime t, RoundingPrecision p) { using namespace std::chrono; if (t.time_since_epoch().count() >= 0) { switch (p) { case RoundingPrecision::HOUR: // not reachable in this context #nocov return time_point_cast(time_point_cast(t)); // not reachable in this context #nocov case RoundingPrecision::MINUTE: return time_point_cast(time_point_cast(t)); case RoundingPrecision::SECOND: return time_point_cast(time_point_cast(t)); case RoundingPrecision::MILLI: return time_point_cast(time_point_cast(t)); case RoundingPrecision::MICRO: return time_point_cast(time_point_cast(t)); case RoundingPrecision::NANO: return time_point_cast(time_point_cast(t)); default: // not reachable in this context #nocov throw std::out_of_range("unknown rounding type"); // not reachable in this context #nocov } } else { switch (p) { case RoundingPrecision::HOUR: // not reachable in this context #nocov return time_point_cast(time_point_cast(t) - hours{1}); // not reachable in this context #nocov case RoundingPrecision::MINUTE: return time_point_cast(time_point_cast(t) - minutes{1}); case RoundingPrecision::SECOND: return time_point_cast(time_point_cast(t) - seconds{1}); case RoundingPrecision::MILLI: return time_point_cast(time_point_cast(t) - milliseconds{1}); case RoundingPrecision::MICRO: return time_point_cast(time_point_cast(t) - microseconds{1}); case RoundingPrecision::NANO: return time_point_cast(time_point_cast(t)); default: // not reachable in this context #nocov throw std::out_of_range("unknown rounding type"); // not reachable in this context #nocov } } } static dtime floor_tz(const dtime t, RoundingPrecision p, const std::string& z) { using namespace std::chrono; switch (p) { case RoundingPrecision::HOUR: { auto t_offset = t + getOffsetCnv(t, z.c_str()); auto t_hours = time_point_cast(time_point_cast(t_offset)); if (t.time_since_epoch() < nanotime::duration::zero() && t_hours > t_offset) { t_hours -= hours{1}; } return t_hours - getOffsetCnv(t_hours, z.c_str()); } case RoundingPrecision::DAY: { auto t_days = date::floor(t + getOffsetCnv(t, z.c_str())); return t_days - getOffsetCnv(t_days, z.c_str()); } case RoundingPrecision::MONTH: { auto t_days = date::floor(t + getOffsetCnv(t, z.c_str())); auto ymd = date::year_month_day(t_days); t_days = date::sys_days(ymd.year()/ymd.month()/date::day(1)); return t_days - getOffsetCnv(t_days, z.c_str()); } case RoundingPrecision::YEAR: { auto t_days = date::floor(t + getOffsetCnv(t, z.c_str())); auto ymd = date::year_month_day(t_days); t_days = date::sys_days(ymd.year()/date::month(1)/date::day(1)); return t_days - getOffsetCnv(t_days, z.c_str()); } default: return floor(t, p); } } static const std::vector makegrid(const dtime start, bool absolute_start, // is start absolute (e.g no rounding) const dtime end, const period p, const std::string& tz) { const auto precision = selectPrecision(p); const auto start_0 = absolute_start ? start : floor_tz(start, precision, tz); const auto end_0 = plus(end, p, tz); std::vector res; auto c = start_0; for (; c < start_0; c = plus(c, p, tz)) { } for(; c <= end_0; c = plus(c, p, tz)) { res.push_back(c); } return res; } static void ceilingtogrid(const dtime* dt, const uint64_t n_dt, const std::vector& grid, dtime* res) { if (grid.size() <= 1) { throw std::range_error("ceilingtogrid: invalid 'grid' argument"); // not reachable in this context #nocov } size_t iy = 0; for (size_t ix=0; ix < n_dt; ++ix) { while (dt[ix] > grid[iy]) ++iy; res[ix] = grid[iy]; // this is safe by grid construction } } // this is really the same as static void floortogrid(const dtime* dt, const uint64_t n_dt, const std::vector& grid, dtime* res) { if (grid.size() <= 1) { throw std::range_error("floortogrid: invalid 'grid' argument"); // not reachable in this context #nocov } size_t iy = 1; for (size_t ix=0; ix < n_dt; ++ix) { while (dt[ix] >= grid[iy]) ++iy; res[ix] = grid[iy-1]; // this is safe by grid construction } } // [[Rcpp::export]] Rcpp::NumericVector ceiling_tz_impl(const Rcpp::NumericVector& nt_v, // vector of 'nanotime' const Rcpp::ComplexVector& prd_v, // scalar period const Rcpp::NumericVector& orig_v, // origin const Rcpp::CharacterVector& tz_v) { // scalar timezone // check tz and orig are scalar: if (orig_v.size() > 1) { Rcpp::stop("'origin' must be scalar"); } if (tz_v.size() > 1) { Rcpp::stop("'tz' must be scalar"); } period prd; memcpy(&prd, reinterpret_cast(&prd_v[0]), sizeof(period)); const auto tz = Rcpp::as(tz_v[0]); // period must be strictly positive if ((prd.getMonths() < 0 || prd.getDays() < 0 || prd.getDuration() < duration::zero()) || prd == period{0, 0, duration::zero()}) { Rcpp::stop("'precision' must be strictly positive"); } const dtime* dt = reinterpret_cast(&nt_v[0]); dtime origin; if (orig_v.size()) { origin = *reinterpret_cast(&orig_v[0]); if (dt[0] > plus(origin, prd, tz)) { Rcpp::stop("when specifying 'origin', the first interval must contain at least one observation"); } } const auto grid = orig_v.size() ? makegrid(origin, true, dt[nt_v.size()-1], prd, tz) : makegrid(dt[0], false, dt[nt_v.size()-1], prd, tz); Rcpp::NumericVector res(nt_v.size()); auto res_dt = reinterpret_cast(&res[0]); ceilingtogrid(dt, nt_v.size(), grid, res_dt); return assignS4("nanotime", res, "integer64"); } // [[Rcpp::export]] Rcpp::NumericVector ceiling_impl(const Rcpp::NumericVector& nt_v, // vector of 'nanotime' const Rcpp::NumericVector& dur_v, // scalar duration const Rcpp::NumericVector& orig_v) { // scalar origin // check orig is scalar: if (orig_v.size() > 1) { Rcpp::stop("'origin' must be scalar"); } int64_t dur; memcpy(&dur, reinterpret_cast(&dur_v[0]), sizeof(int64_t)); // duration must be strictly positive if (dur < 0) { Rcpp::stop("'precision' must be strictly positive"); } const auto* dt = reinterpret_cast(&nt_v[0]); Rcpp::NumericVector res(nt_v.size()); auto res_dur = reinterpret_cast(&res[0]); const auto origin = orig_v.size() ? *reinterpret_cast(&orig_v[0]) : 0; for (R_xlen_t i=0; i < res.size(); ++i) { res_dur[i] = ((dt[i] - origin) / dur) * dur + origin; if (res_dur[i] > 0 && res_dur[i] < dt[i]) { // round up res_dur[i] += dur; } } return assignS4("nanotime", res, "integer64"); return res; } // [[Rcpp::export]] Rcpp::NumericVector floor_tz_impl(const Rcpp::NumericVector& nt_v, // vector of 'nanotime' const Rcpp::ComplexVector& prd_v, // scalar period const Rcpp::NumericVector& orig_v, // origin const Rcpp::CharacterVector& tz_v) { // scalar timezone // check tz and orig are scalar: if (orig_v.size() > 1) { Rcpp::stop("'origin' must be scalar"); } if (tz_v.size() > 1) { Rcpp::stop("'tz' must be scalar"); } const auto tz = Rcpp::as(tz_v[0]); period prd; memcpy(&prd, reinterpret_cast(&prd_v[0]), sizeof(period)); // period must be strictly positive if ((prd.getMonths() < 0 || prd.getDays() < 0 || prd.getDuration() < duration::zero()) || prd == period{0, 0, duration::zero()}) { Rcpp::stop("'precision' must be strictly positive"); } const auto dt = reinterpret_cast(&nt_v[0]); dtime origin; if (orig_v.size()) { origin = *reinterpret_cast(&orig_v[0]); if (dt[0] > plus(origin, prd, tz)) { Rcpp::stop("when specifying 'origin', the first interval must contain at least one observation"); } } // additionally if origin is supplied, verify it's not more than one interval before the first observation LLL const auto grid = orig_v.size() ? makegrid(origin, true, dt[nt_v.size()-1], prd, tz) : makegrid(dt[0], false, dt[nt_v.size()-1], prd, tz); Rcpp::NumericVector res(nt_v.size()); auto res_dt = reinterpret_cast(&res[0]); floortogrid(dt, nt_v.size(), grid, res_dt); return assignS4("nanotime", res, "integer64"); } // [[Rcpp::export]] Rcpp::NumericVector floor_impl(const Rcpp::NumericVector& nt_v, // vector of 'nanotime' const Rcpp::NumericVector& dur_v, // scalar duration const Rcpp::NumericVector& orig_v) { // origin // check orig are scalar: if (orig_v.size() > 1) Rcpp::stop("'origin' must be scalar"); int64_t dur; memcpy(&dur, reinterpret_cast(&dur_v[0]), sizeof(int64_t)); // duration must be strictly positive if (dur < 0) { Rcpp::stop("'precision' must be strictly positive"); } const auto* dt = reinterpret_cast(&nt_v[0]); Rcpp::NumericVector res(nt_v.size()); auto res_dur = reinterpret_cast(&res[0]); const auto origin = orig_v.size() ? *reinterpret_cast(&orig_v[0]) : 0; for (R_xlen_t i=0; i < res.size(); ++i) { res_dur[i] = ((dt[i] - origin) / dur) * dur + origin; if (res_dur[i] < 0 && res_dur[i] > dt[i]) { res_dur[i] -= dur; } } return assignS4("nanotime", res, "integer64"); } nanotime/src/RcppExports.cpp0000644000176200001440000014337214131560240015656 0ustar liggesusers// Generated by using Rcpp::compileAttributes() -> do not edit by hand // Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 #include using namespace Rcpp; #ifdef RCPP_USE_GLOBAL_ROSTREAM Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get(); Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get(); #endif // duration_from_string_impl Rcpp::NumericVector duration_from_string_impl(Rcpp::CharacterVector str); RcppExport SEXP _nanotime_duration_from_string_impl(SEXP strSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type str(strSEXP); rcpp_result_gen = Rcpp::wrap(duration_from_string_impl(str)); return rcpp_result_gen; END_RCPP } // duration_to_string_impl Rcpp::CharacterVector duration_to_string_impl(Rcpp::NumericVector dur); RcppExport SEXP _nanotime_duration_to_string_impl(SEXP durSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::NumericVector >::type dur(durSEXP); rcpp_result_gen = Rcpp::wrap(duration_to_string_impl(dur)); return rcpp_result_gen; END_RCPP } // duration_is_na_impl Rcpp::LogicalVector duration_is_na_impl(Rcpp::NumericVector dur); RcppExport SEXP _nanotime_duration_is_na_impl(SEXP durSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::NumericVector >::type dur(durSEXP); rcpp_result_gen = Rcpp::wrap(duration_is_na_impl(dur)); return rcpp_result_gen; END_RCPP } // make_duration_impl Rcpp::NumericVector make_duration_impl(const Rcpp::NumericVector h_nv, const Rcpp::NumericVector m_nv, const Rcpp::NumericVector s_nv, const Rcpp::NumericVector n_nv); RcppExport SEXP _nanotime_make_duration_impl(SEXP h_nvSEXP, SEXP m_nvSEXP, SEXP s_nvSEXP, SEXP n_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type h_nv(h_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type m_nv(m_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type s_nv(s_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type n_nv(n_nvSEXP); rcpp_result_gen = Rcpp::wrap(make_duration_impl(h_nv, m_nv, s_nv, n_nv)); return rcpp_result_gen; END_RCPP } // nanoduration_subset_numeric_impl Rcpp::NumericVector nanoduration_subset_numeric_impl(const Rcpp::NumericVector& v, const Rcpp::NumericVector& idx); RcppExport SEXP _nanotime_nanoduration_subset_numeric_impl(SEXP vSEXP, SEXP idxSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type idx(idxSEXP); rcpp_result_gen = Rcpp::wrap(nanoduration_subset_numeric_impl(v, idx)); return rcpp_result_gen; END_RCPP } // nanoduration_subset_logical_impl Rcpp::NumericVector nanoduration_subset_logical_impl(const Rcpp::NumericVector& v, const Rcpp::LogicalVector& idx_p); RcppExport SEXP _nanotime_nanoduration_subset_logical_impl(SEXP vSEXP, SEXP idx_pSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector& >::type idx_p(idx_pSEXP); rcpp_result_gen = Rcpp::wrap(nanoduration_subset_logical_impl(v, idx_p)); return rcpp_result_gen; END_RCPP } // nanoival_intersect_idx_time_interval_impl Rcpp::List nanoival_intersect_idx_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2); RcppExport SEXP _nanotime_nanoival_intersect_idx_time_interval_impl(SEXP nv1SEXP, SEXP nv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv2(nv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_intersect_idx_time_interval_impl(nv1, nv2)); return rcpp_result_gen; END_RCPP } // nanoival_intersect_idx_time_interval_logical_impl Rcpp::LogicalVector nanoival_intersect_idx_time_interval_logical_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2); RcppExport SEXP _nanotime_nanoival_intersect_idx_time_interval_logical_impl(SEXP nv1SEXP, SEXP nv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv2(nv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_intersect_idx_time_interval_logical_impl(nv1, nv2)); return rcpp_result_gen; END_RCPP } // nanoival_intersect_time_interval_impl Rcpp::S4 nanoival_intersect_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2); RcppExport SEXP _nanotime_nanoival_intersect_time_interval_impl(SEXP nv1SEXP, SEXP nv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv2(nv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_intersect_time_interval_impl(nv1, nv2)); return rcpp_result_gen; END_RCPP } // nanoival_setdiff_time_interval_impl Rcpp::NumericVector nanoival_setdiff_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector nv2); RcppExport SEXP _nanotime_nanoival_setdiff_time_interval_impl(SEXP nv1SEXP, SEXP nv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv2(nv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_setdiff_time_interval_impl(nv1, nv2)); return rcpp_result_gen; END_RCPP } // nanoival_union_impl Rcpp::ComplexVector nanoival_union_impl(const Rcpp::ComplexVector nv1, const Rcpp::ComplexVector nv2); RcppExport SEXP _nanotime_nanoival_union_impl(SEXP nv1SEXP, SEXP nv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv2(nv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_union_impl(nv1, nv2)); return rcpp_result_gen; END_RCPP } // nanoival_intersect_impl Rcpp::ComplexVector nanoival_intersect_impl(const Rcpp::ComplexVector nv1, const Rcpp::ComplexVector nv2); RcppExport SEXP _nanotime_nanoival_intersect_impl(SEXP nv1SEXP, SEXP nv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv2(nv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_intersect_impl(nv1, nv2)); return rcpp_result_gen; END_RCPP } // nanoival_setdiff_impl Rcpp::ComplexVector nanoival_setdiff_impl(const Rcpp::ComplexVector nv1, const Rcpp::ComplexVector nv2); RcppExport SEXP _nanotime_nanoival_setdiff_impl(SEXP nv1SEXP, SEXP nv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nv2(nv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_setdiff_impl(nv1, nv2)); return rcpp_result_gen; END_RCPP } // nanoival_is_unsorted_impl bool nanoival_is_unsorted_impl(const Rcpp::ComplexVector nvec, const Rcpp::LogicalVector strictlyvec); RcppExport SEXP _nanotime_nanoival_is_unsorted_impl(SEXP nvecSEXP, SEXP strictlyvecSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nvec(nvecSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector >::type strictlyvec(strictlyvecSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_is_unsorted_impl(nvec, strictlyvec)); return rcpp_result_gen; END_RCPP } // nanoival_sort_impl const Rcpp::ComplexVector nanoival_sort_impl(const Rcpp::ComplexVector nvec, const Rcpp::LogicalVector decreasingvec); RcppExport SEXP _nanotime_nanoival_sort_impl(SEXP nvecSEXP, SEXP decreasingvecSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nvec(nvecSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector >::type decreasingvec(decreasingvecSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_sort_impl(nvec, decreasingvec)); return rcpp_result_gen; END_RCPP } // nanoival_sort_impl2 const Rcpp::ComplexVector nanoival_sort_impl2(const Rcpp::ComplexVector nvec, bool decreasing); RcppExport SEXP _nanotime_nanoival_sort_impl2(SEXP nvecSEXP, SEXP decreasingSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type nvec(nvecSEXP); Rcpp::traits::input_parameter< bool >::type decreasing(decreasingSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_sort_impl2(nvec, decreasing)); return rcpp_result_gen; END_RCPP } // nanoival_lt_impl Rcpp::LogicalVector nanoival_lt_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2); RcppExport SEXP _nanotime_nanoival_lt_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_lt_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_le_impl Rcpp::LogicalVector nanoival_le_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2); RcppExport SEXP _nanotime_nanoival_le_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_le_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_gt_impl Rcpp::LogicalVector nanoival_gt_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2); RcppExport SEXP _nanotime_nanoival_gt_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_gt_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_ge_impl Rcpp::LogicalVector nanoival_ge_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2); RcppExport SEXP _nanotime_nanoival_ge_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_ge_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_eq_impl Rcpp::LogicalVector nanoival_eq_impl(const Rcpp::ComplexVector n1, const Rcpp::ComplexVector n2); RcppExport SEXP _nanotime_nanoival_eq_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_eq_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_ne_impl Rcpp::LogicalVector nanoival_ne_impl(Rcpp::ComplexVector n1, Rcpp::ComplexVector n2); RcppExport SEXP _nanotime_nanoival_ne_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< Rcpp::ComplexVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_ne_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_plus_impl Rcpp::ComplexVector nanoival_plus_impl(const Rcpp::ComplexVector n1, const Rcpp::NumericVector n2); RcppExport SEXP _nanotime_nanoival_plus_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_plus_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_minus_impl Rcpp::ComplexVector nanoival_minus_impl(const Rcpp::ComplexVector n1, const Rcpp::NumericVector n2); RcppExport SEXP _nanotime_nanoival_minus_impl(SEXP n1SEXP, SEXP n2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type n1(n1SEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type n2(n2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_minus_impl(n1, n2)); return rcpp_result_gen; END_RCPP } // nanoival_setdiff_idx_time_interval_impl Rcpp::NumericVector nanoival_setdiff_idx_time_interval_impl(const Rcpp::NumericVector nv1, const Rcpp::ComplexVector cv2); RcppExport SEXP _nanotime_nanoival_setdiff_idx_time_interval_impl(SEXP nv1SEXP, SEXP cv2SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type nv1(nv1SEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type cv2(cv2SEXP); rcpp_result_gen = Rcpp::wrap(nanoival_setdiff_idx_time_interval_impl(nv1, cv2)); return rcpp_result_gen; END_RCPP } // nanoival_new_impl Rcpp::S4 nanoival_new_impl(const Rcpp::NumericVector sv, const Rcpp::NumericVector ev, const Rcpp::LogicalVector sopenv, const Rcpp::LogicalVector eopenv); RcppExport SEXP _nanotime_nanoival_new_impl(SEXP svSEXP, SEXP evSEXP, SEXP sopenvSEXP, SEXP eopenvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type sv(svSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type ev(evSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector >::type sopenv(sopenvSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector >::type eopenv(eopenvSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_new_impl(sv, ev, sopenv, eopenv)); return rcpp_result_gen; END_RCPP } // nanoival_get_start_impl Rcpp::NumericVector nanoival_get_start_impl(const Rcpp::ComplexVector cv); RcppExport SEXP _nanotime_nanoival_get_start_impl(SEXP cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type cv(cvSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_get_start_impl(cv)); return rcpp_result_gen; END_RCPP } // nanoival_get_end_impl Rcpp::NumericVector nanoival_get_end_impl(const Rcpp::ComplexVector cv); RcppExport SEXP _nanotime_nanoival_get_end_impl(SEXP cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type cv(cvSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_get_end_impl(cv)); return rcpp_result_gen; END_RCPP } // nanoival_get_sopen_impl Rcpp::LogicalVector nanoival_get_sopen_impl(const Rcpp::ComplexVector cv); RcppExport SEXP _nanotime_nanoival_get_sopen_impl(SEXP cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type cv(cvSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_get_sopen_impl(cv)); return rcpp_result_gen; END_RCPP } // nanoival_get_eopen_impl Rcpp::LogicalVector nanoival_get_eopen_impl(const Rcpp::ComplexVector cv); RcppExport SEXP _nanotime_nanoival_get_eopen_impl(SEXP cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type cv(cvSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_get_eopen_impl(cv)); return rcpp_result_gen; END_RCPP } // nanoival_isna_impl Rcpp::LogicalVector nanoival_isna_impl(const Rcpp::ComplexVector cv); RcppExport SEXP _nanotime_nanoival_isna_impl(SEXP cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type cv(cvSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_isna_impl(cv)); return rcpp_result_gen; END_RCPP } // nanoival_make_impl Rcpp::ComplexVector nanoival_make_impl(const Rcpp::CharacterVector nt_v, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_nanoival_make_impl(SEXP nt_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type nt_v(nt_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_make_impl(nt_v, tz_v)); return rcpp_result_gen; END_RCPP } // nanoival_subset_numeric_impl Rcpp::ComplexVector nanoival_subset_numeric_impl(const Rcpp::ComplexVector& v, const Rcpp::NumericVector& idx); RcppExport SEXP _nanotime_nanoival_subset_numeric_impl(SEXP vSEXP, SEXP idxSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type idx(idxSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_subset_numeric_impl(v, idx)); return rcpp_result_gen; END_RCPP } // nanoival_subset_logical_impl Rcpp::ComplexVector nanoival_subset_logical_impl(const Rcpp::ComplexVector& v, const Rcpp::LogicalVector& idx_p); RcppExport SEXP _nanotime_nanoival_subset_logical_impl(SEXP vSEXP, SEXP idx_pSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector& >::type idx_p(idx_pSEXP); rcpp_result_gen = Rcpp::wrap(nanoival_subset_logical_impl(v, idx_p)); return rcpp_result_gen; END_RCPP } // nanotime_wday_impl Rcpp::IntegerVector nanotime_wday_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_nanotime_wday_impl(SEXP tm_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type tm_v(tm_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(nanotime_wday_impl(tm_v, tz_v)); return rcpp_result_gen; END_RCPP } // nanotime_mday_impl Rcpp::IntegerVector nanotime_mday_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_nanotime_mday_impl(SEXP tm_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type tm_v(tm_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(nanotime_mday_impl(tm_v, tz_v)); return rcpp_result_gen; END_RCPP } // nanotime_month_impl Rcpp::IntegerVector nanotime_month_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_nanotime_month_impl(SEXP tm_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type tm_v(tm_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(nanotime_month_impl(tm_v, tz_v)); return rcpp_result_gen; END_RCPP } // nanotime_year_impl Rcpp::IntegerVector nanotime_year_impl(const Rcpp::NumericVector tm_v, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_nanotime_year_impl(SEXP tm_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type tm_v(tm_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(nanotime_year_impl(tm_v, tz_v)); return rcpp_result_gen; END_RCPP } // nanotime_make_impl Rcpp::NumericVector nanotime_make_impl(const Rcpp::CharacterVector nt_v, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_nanotime_make_impl(SEXP nt_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type nt_v(nt_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(nanotime_make_impl(nt_v, tz_v)); return rcpp_result_gen; END_RCPP } // nanotime_subset_numeric_impl Rcpp::NumericVector nanotime_subset_numeric_impl(const Rcpp::NumericVector& v, const Rcpp::NumericVector& idx); RcppExport SEXP _nanotime_nanotime_subset_numeric_impl(SEXP vSEXP, SEXP idxSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type idx(idxSEXP); rcpp_result_gen = Rcpp::wrap(nanotime_subset_numeric_impl(v, idx)); return rcpp_result_gen; END_RCPP } // nanotime_subset_logical_impl Rcpp::NumericVector nanotime_subset_logical_impl(const Rcpp::NumericVector& v, const Rcpp::LogicalVector& idx_p); RcppExport SEXP _nanotime_nanotime_subset_logical_impl(SEXP vSEXP, SEXP idx_pSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector& >::type idx_p(idx_pSEXP); rcpp_result_gen = Rcpp::wrap(nanotime_subset_logical_impl(v, idx_p)); return rcpp_result_gen; END_RCPP } // period_from_string_impl Rcpp::ComplexVector period_from_string_impl(Rcpp::CharacterVector str); RcppExport SEXP _nanotime_period_from_string_impl(SEXP strSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::CharacterVector >::type str(strSEXP); rcpp_result_gen = Rcpp::wrap(period_from_string_impl(str)); return rcpp_result_gen; END_RCPP } // period_from_parts_impl Rcpp::ComplexVector period_from_parts_impl(Rcpp::IntegerVector months_v, Rcpp::IntegerVector days_v, Rcpp::NumericVector dur_v); RcppExport SEXP _nanotime_period_from_parts_impl(SEXP months_vSEXP, SEXP days_vSEXP, SEXP dur_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type months_v(months_vSEXP); Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type days_v(days_vSEXP); Rcpp::traits::input_parameter< Rcpp::NumericVector >::type dur_v(dur_vSEXP); rcpp_result_gen = Rcpp::wrap(period_from_parts_impl(months_v, days_v, dur_v)); return rcpp_result_gen; END_RCPP } // period_to_string_impl Rcpp::CharacterVector period_to_string_impl(Rcpp::ComplexVector prd); RcppExport SEXP _nanotime_period_to_string_impl(SEXP prdSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::ComplexVector >::type prd(prdSEXP); rcpp_result_gen = Rcpp::wrap(period_to_string_impl(prd)); return rcpp_result_gen; END_RCPP } // period_from_integer64_impl Rcpp::ComplexVector period_from_integer64_impl(Rcpp::NumericVector i64); RcppExport SEXP _nanotime_period_from_integer64_impl(SEXP i64SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::NumericVector >::type i64(i64SEXP); rcpp_result_gen = Rcpp::wrap(period_from_integer64_impl(i64)); return rcpp_result_gen; END_RCPP } // period_from_integer_impl Rcpp::ComplexVector period_from_integer_impl(Rcpp::IntegerVector iint); RcppExport SEXP _nanotime_period_from_integer_impl(SEXP iintSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type iint(iintSEXP); rcpp_result_gen = Rcpp::wrap(period_from_integer_impl(iint)); return rcpp_result_gen; END_RCPP } // period_from_double_impl Rcpp::ComplexVector period_from_double_impl(Rcpp::NumericVector dbl); RcppExport SEXP _nanotime_period_from_double_impl(SEXP dblSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< Rcpp::NumericVector >::type dbl(dblSEXP); rcpp_result_gen = Rcpp::wrap(period_from_double_impl(dbl)); return rcpp_result_gen; END_RCPP } // plus_period_period_impl Rcpp::ComplexVector plus_period_period_impl(const Rcpp::ComplexVector e1_nv, const Rcpp::ComplexVector e2_nv); RcppExport SEXP _nanotime_plus_period_period_impl(SEXP e1_nvSEXP, SEXP e2_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_nv(e1_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_nv(e2_nvSEXP); rcpp_result_gen = Rcpp::wrap(plus_period_period_impl(e1_nv, e2_nv)); return rcpp_result_gen; END_RCPP } // minus_period_impl Rcpp::ComplexVector minus_period_impl(const Rcpp::ComplexVector e1_cv); RcppExport SEXP _nanotime_minus_period_impl(SEXP e1_cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); rcpp_result_gen = Rcpp::wrap(minus_period_impl(e1_cv)); return rcpp_result_gen; END_RCPP } // minus_period_period_impl Rcpp::ComplexVector minus_period_period_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::ComplexVector e2_cv); RcppExport SEXP _nanotime_minus_period_period_impl(SEXP e1_cvSEXP, SEXP e2_cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_cv(e2_cvSEXP); rcpp_result_gen = Rcpp::wrap(minus_period_period_impl(e1_cv, e2_cv)); return rcpp_result_gen; END_RCPP } // eq_period_period_impl Rcpp::LogicalVector eq_period_period_impl(const Rcpp::ComplexVector e1_p, const Rcpp::ComplexVector e2_p); RcppExport SEXP _nanotime_eq_period_period_impl(SEXP e1_pSEXP, SEXP e2_pSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_p(e1_pSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_p(e2_pSEXP); rcpp_result_gen = Rcpp::wrap(eq_period_period_impl(e1_p, e2_p)); return rcpp_result_gen; END_RCPP } // ne_period_period_impl Rcpp::LogicalVector ne_period_period_impl(const Rcpp::ComplexVector e1_p, const Rcpp::ComplexVector e2_p); RcppExport SEXP _nanotime_ne_period_period_impl(SEXP e1_pSEXP, SEXP e2_pSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_p(e1_pSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_p(e2_pSEXP); rcpp_result_gen = Rcpp::wrap(ne_period_period_impl(e1_p, e2_p)); return rcpp_result_gen; END_RCPP } // plus_period_integer64_impl Rcpp::ComplexVector plus_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv); RcppExport SEXP _nanotime_plus_period_integer64_impl(SEXP e1_cvSEXP, SEXP e2_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e2_nv(e2_nvSEXP); rcpp_result_gen = Rcpp::wrap(plus_period_integer64_impl(e1_cv, e2_nv)); return rcpp_result_gen; END_RCPP } // minus_period_integer64_impl Rcpp::ComplexVector minus_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv); RcppExport SEXP _nanotime_minus_period_integer64_impl(SEXP e1_cvSEXP, SEXP e2_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e2_nv(e2_nvSEXP); rcpp_result_gen = Rcpp::wrap(minus_period_integer64_impl(e1_cv, e2_nv)); return rcpp_result_gen; END_RCPP } // multiplies_period_integer64_impl Rcpp::ComplexVector multiplies_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv); RcppExport SEXP _nanotime_multiplies_period_integer64_impl(SEXP e1_cvSEXP, SEXP e2_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e2_nv(e2_nvSEXP); rcpp_result_gen = Rcpp::wrap(multiplies_period_integer64_impl(e1_cv, e2_nv)); return rcpp_result_gen; END_RCPP } // divides_period_integer64_impl Rcpp::ComplexVector divides_period_integer64_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv); RcppExport SEXP _nanotime_divides_period_integer64_impl(SEXP e1_cvSEXP, SEXP e2_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e2_nv(e2_nvSEXP); rcpp_result_gen = Rcpp::wrap(divides_period_integer64_impl(e1_cv, e2_nv)); return rcpp_result_gen; END_RCPP } // multiplies_period_double_impl Rcpp::ComplexVector multiplies_period_double_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv); RcppExport SEXP _nanotime_multiplies_period_double_impl(SEXP e1_cvSEXP, SEXP e2_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e2_nv(e2_nvSEXP); rcpp_result_gen = Rcpp::wrap(multiplies_period_double_impl(e1_cv, e2_nv)); return rcpp_result_gen; END_RCPP } // divides_period_double_impl Rcpp::ComplexVector divides_period_double_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::NumericVector e2_nv); RcppExport SEXP _nanotime_divides_period_double_impl(SEXP e1_cvSEXP, SEXP e2_nvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e2_nv(e2_nvSEXP); rcpp_result_gen = Rcpp::wrap(divides_period_double_impl(e1_cv, e2_nv)); return rcpp_result_gen; END_RCPP } // minus_integer64_period_impl Rcpp::ComplexVector minus_integer64_period_impl(const Rcpp::NumericVector e1_nv, const Rcpp::ComplexVector e2_cv); RcppExport SEXP _nanotime_minus_integer64_period_impl(SEXP e1_nvSEXP, SEXP e2_cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e1_nv(e1_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_cv(e2_cvSEXP); rcpp_result_gen = Rcpp::wrap(minus_integer64_period_impl(e1_nv, e2_cv)); return rcpp_result_gen; END_RCPP } // plus_nanotime_period_impl Rcpp::NumericVector plus_nanotime_period_impl(const Rcpp::NumericVector e1_nv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_plus_nanotime_period_impl(SEXP e1_nvSEXP, SEXP e2_cvSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e1_nv(e1_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_cv(e2_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(plus_nanotime_period_impl(e1_nv, e2_cv, tz_v)); return rcpp_result_gen; END_RCPP } // minus_nanotime_period_impl Rcpp::NumericVector minus_nanotime_period_impl(const Rcpp::NumericVector e1_nv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_minus_nanotime_period_impl(SEXP e1_nvSEXP, SEXP e2_cvSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type e1_nv(e1_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_cv(e2_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(minus_nanotime_period_impl(e1_nv, e2_cv, tz_v)); return rcpp_result_gen; END_RCPP } // plus_nanoival_period_impl Rcpp::ComplexVector plus_nanoival_period_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_plus_nanoival_period_impl(SEXP e1_cvSEXP, SEXP e2_cvSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_cv(e2_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(plus_nanoival_period_impl(e1_cv, e2_cv, tz_v)); return rcpp_result_gen; END_RCPP } // minus_nanoival_period_impl Rcpp::ComplexVector minus_nanoival_period_impl(const Rcpp::ComplexVector e1_cv, const Rcpp::ComplexVector e2_cv, const Rcpp::CharacterVector tz_v); RcppExport SEXP _nanotime_minus_nanoival_period_impl(SEXP e1_cvSEXP, SEXP e2_cvSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e1_cv(e1_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e2_cv(e2_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(minus_nanoival_period_impl(e1_cv, e2_cv, tz_v)); return rcpp_result_gen; END_RCPP } // period_month_impl Rcpp::NumericVector period_month_impl(const Rcpp::ComplexVector e_n); RcppExport SEXP _nanotime_period_month_impl(SEXP e_nSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e_n(e_nSEXP); rcpp_result_gen = Rcpp::wrap(period_month_impl(e_n)); return rcpp_result_gen; END_RCPP } // period_day_impl Rcpp::NumericVector period_day_impl(const Rcpp::ComplexVector e_n); RcppExport SEXP _nanotime_period_day_impl(SEXP e_nSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e_n(e_nSEXP); rcpp_result_gen = Rcpp::wrap(period_day_impl(e_n)); return rcpp_result_gen; END_RCPP } // period_duration_impl Rcpp::S4 period_duration_impl(const Rcpp::ComplexVector e_n); RcppExport SEXP _nanotime_period_duration_impl(SEXP e_nSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type e_n(e_nSEXP); rcpp_result_gen = Rcpp::wrap(period_duration_impl(e_n)); return rcpp_result_gen; END_RCPP } // period_isna_impl Rcpp::LogicalVector period_isna_impl(const Rcpp::ComplexVector cv); RcppExport SEXP _nanotime_period_isna_impl(SEXP cvSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type cv(cvSEXP); rcpp_result_gen = Rcpp::wrap(period_isna_impl(cv)); return rcpp_result_gen; END_RCPP } // period_seq_from_to_impl Rcpp::NumericVector period_seq_from_to_impl(const Rcpp::NumericVector from_nv, const Rcpp::NumericVector to_nv, const Rcpp::ComplexVector by_cv, const std::string tz); RcppExport SEXP _nanotime_period_seq_from_to_impl(SEXP from_nvSEXP, SEXP to_nvSEXP, SEXP by_cvSEXP, SEXP tzSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type from_nv(from_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type to_nv(to_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type by_cv(by_cvSEXP); Rcpp::traits::input_parameter< const std::string >::type tz(tzSEXP); rcpp_result_gen = Rcpp::wrap(period_seq_from_to_impl(from_nv, to_nv, by_cv, tz)); return rcpp_result_gen; END_RCPP } // period_seq_from_length_impl Rcpp::NumericVector period_seq_from_length_impl(const Rcpp::NumericVector from_nv, const Rcpp::ComplexVector by_cv, const Rcpp::NumericVector n_nv, const std::string tz); RcppExport SEXP _nanotime_period_seq_from_length_impl(SEXP from_nvSEXP, SEXP by_cvSEXP, SEXP n_nvSEXP, SEXP tzSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type from_nv(from_nvSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector >::type by_cv(by_cvSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector >::type n_nv(n_nvSEXP); Rcpp::traits::input_parameter< const std::string >::type tz(tzSEXP); rcpp_result_gen = Rcpp::wrap(period_seq_from_length_impl(from_nv, by_cv, n_nv, tz)); return rcpp_result_gen; END_RCPP } // period_subset_numeric_impl Rcpp::ComplexVector period_subset_numeric_impl(const Rcpp::ComplexVector& v, const Rcpp::NumericVector& idx); RcppExport SEXP _nanotime_period_subset_numeric_impl(SEXP vSEXP, SEXP idxSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type idx(idxSEXP); rcpp_result_gen = Rcpp::wrap(period_subset_numeric_impl(v, idx)); return rcpp_result_gen; END_RCPP } // period_subset_logical_impl Rcpp::ComplexVector period_subset_logical_impl(const Rcpp::ComplexVector& v, const Rcpp::LogicalVector& idx_p); RcppExport SEXP _nanotime_period_subset_logical_impl(SEXP vSEXP, SEXP idx_pSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::ComplexVector& >::type v(vSEXP); Rcpp::traits::input_parameter< const Rcpp::LogicalVector& >::type idx_p(idx_pSEXP); rcpp_result_gen = Rcpp::wrap(period_subset_logical_impl(v, idx_p)); return rcpp_result_gen; END_RCPP } // ceiling_tz_impl Rcpp::NumericVector ceiling_tz_impl(const Rcpp::NumericVector& nt_v, const Rcpp::ComplexVector& prd_v, const Rcpp::NumericVector& orig_v, const Rcpp::CharacterVector& tz_v); RcppExport SEXP _nanotime_ceiling_tz_impl(SEXP nt_vSEXP, SEXP prd_vSEXP, SEXP orig_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type nt_v(nt_vSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector& >::type prd_v(prd_vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type orig_v(orig_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector& >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(ceiling_tz_impl(nt_v, prd_v, orig_v, tz_v)); return rcpp_result_gen; END_RCPP } // ceiling_impl Rcpp::NumericVector ceiling_impl(const Rcpp::NumericVector& nt_v, const Rcpp::NumericVector& dur_v, const Rcpp::NumericVector& orig_v); RcppExport SEXP _nanotime_ceiling_impl(SEXP nt_vSEXP, SEXP dur_vSEXP, SEXP orig_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type nt_v(nt_vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type dur_v(dur_vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type orig_v(orig_vSEXP); rcpp_result_gen = Rcpp::wrap(ceiling_impl(nt_v, dur_v, orig_v)); return rcpp_result_gen; END_RCPP } // floor_tz_impl Rcpp::NumericVector floor_tz_impl(const Rcpp::NumericVector& nt_v, const Rcpp::ComplexVector& prd_v, const Rcpp::NumericVector& orig_v, const Rcpp::CharacterVector& tz_v); RcppExport SEXP _nanotime_floor_tz_impl(SEXP nt_vSEXP, SEXP prd_vSEXP, SEXP orig_vSEXP, SEXP tz_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type nt_v(nt_vSEXP); Rcpp::traits::input_parameter< const Rcpp::ComplexVector& >::type prd_v(prd_vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type orig_v(orig_vSEXP); Rcpp::traits::input_parameter< const Rcpp::CharacterVector& >::type tz_v(tz_vSEXP); rcpp_result_gen = Rcpp::wrap(floor_tz_impl(nt_v, prd_v, orig_v, tz_v)); return rcpp_result_gen; END_RCPP } // floor_impl Rcpp::NumericVector floor_impl(const Rcpp::NumericVector& nt_v, const Rcpp::NumericVector& dur_v, const Rcpp::NumericVector& orig_v); RcppExport SEXP _nanotime_floor_impl(SEXP nt_vSEXP, SEXP dur_vSEXP, SEXP orig_vSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type nt_v(nt_vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type dur_v(dur_vSEXP); Rcpp::traits::input_parameter< const Rcpp::NumericVector& >::type orig_v(orig_vSEXP); rcpp_result_gen = Rcpp::wrap(floor_impl(nt_v, dur_v, orig_v)); return rcpp_result_gen; END_RCPP } static const R_CallMethodDef CallEntries[] = { {"_nanotime_duration_from_string_impl", (DL_FUNC) &_nanotime_duration_from_string_impl, 1}, {"_nanotime_duration_to_string_impl", (DL_FUNC) &_nanotime_duration_to_string_impl, 1}, {"_nanotime_duration_is_na_impl", (DL_FUNC) &_nanotime_duration_is_na_impl, 1}, {"_nanotime_make_duration_impl", (DL_FUNC) &_nanotime_make_duration_impl, 4}, {"_nanotime_nanoduration_subset_numeric_impl", (DL_FUNC) &_nanotime_nanoduration_subset_numeric_impl, 2}, {"_nanotime_nanoduration_subset_logical_impl", (DL_FUNC) &_nanotime_nanoduration_subset_logical_impl, 2}, {"_nanotime_nanoival_intersect_idx_time_interval_impl", (DL_FUNC) &_nanotime_nanoival_intersect_idx_time_interval_impl, 2}, {"_nanotime_nanoival_intersect_idx_time_interval_logical_impl", (DL_FUNC) &_nanotime_nanoival_intersect_idx_time_interval_logical_impl, 2}, {"_nanotime_nanoival_intersect_time_interval_impl", (DL_FUNC) &_nanotime_nanoival_intersect_time_interval_impl, 2}, {"_nanotime_nanoival_setdiff_time_interval_impl", (DL_FUNC) &_nanotime_nanoival_setdiff_time_interval_impl, 2}, {"_nanotime_nanoival_union_impl", (DL_FUNC) &_nanotime_nanoival_union_impl, 2}, {"_nanotime_nanoival_intersect_impl", (DL_FUNC) &_nanotime_nanoival_intersect_impl, 2}, {"_nanotime_nanoival_setdiff_impl", (DL_FUNC) &_nanotime_nanoival_setdiff_impl, 2}, {"_nanotime_nanoival_is_unsorted_impl", (DL_FUNC) &_nanotime_nanoival_is_unsorted_impl, 2}, {"_nanotime_nanoival_sort_impl", (DL_FUNC) &_nanotime_nanoival_sort_impl, 2}, {"_nanotime_nanoival_sort_impl2", (DL_FUNC) &_nanotime_nanoival_sort_impl2, 2}, {"_nanotime_nanoival_lt_impl", (DL_FUNC) &_nanotime_nanoival_lt_impl, 2}, {"_nanotime_nanoival_le_impl", (DL_FUNC) &_nanotime_nanoival_le_impl, 2}, {"_nanotime_nanoival_gt_impl", (DL_FUNC) &_nanotime_nanoival_gt_impl, 2}, {"_nanotime_nanoival_ge_impl", (DL_FUNC) &_nanotime_nanoival_ge_impl, 2}, {"_nanotime_nanoival_eq_impl", (DL_FUNC) &_nanotime_nanoival_eq_impl, 2}, {"_nanotime_nanoival_ne_impl", (DL_FUNC) &_nanotime_nanoival_ne_impl, 2}, {"_nanotime_nanoival_plus_impl", (DL_FUNC) &_nanotime_nanoival_plus_impl, 2}, {"_nanotime_nanoival_minus_impl", (DL_FUNC) &_nanotime_nanoival_minus_impl, 2}, {"_nanotime_nanoival_setdiff_idx_time_interval_impl", (DL_FUNC) &_nanotime_nanoival_setdiff_idx_time_interval_impl, 2}, {"_nanotime_nanoival_new_impl", (DL_FUNC) &_nanotime_nanoival_new_impl, 4}, {"_nanotime_nanoival_get_start_impl", (DL_FUNC) &_nanotime_nanoival_get_start_impl, 1}, {"_nanotime_nanoival_get_end_impl", (DL_FUNC) &_nanotime_nanoival_get_end_impl, 1}, {"_nanotime_nanoival_get_sopen_impl", (DL_FUNC) &_nanotime_nanoival_get_sopen_impl, 1}, {"_nanotime_nanoival_get_eopen_impl", (DL_FUNC) &_nanotime_nanoival_get_eopen_impl, 1}, {"_nanotime_nanoival_isna_impl", (DL_FUNC) &_nanotime_nanoival_isna_impl, 1}, {"_nanotime_nanoival_make_impl", (DL_FUNC) &_nanotime_nanoival_make_impl, 2}, {"_nanotime_nanoival_subset_numeric_impl", (DL_FUNC) &_nanotime_nanoival_subset_numeric_impl, 2}, {"_nanotime_nanoival_subset_logical_impl", (DL_FUNC) &_nanotime_nanoival_subset_logical_impl, 2}, {"_nanotime_nanotime_wday_impl", (DL_FUNC) &_nanotime_nanotime_wday_impl, 2}, {"_nanotime_nanotime_mday_impl", (DL_FUNC) &_nanotime_nanotime_mday_impl, 2}, {"_nanotime_nanotime_month_impl", (DL_FUNC) &_nanotime_nanotime_month_impl, 2}, {"_nanotime_nanotime_year_impl", (DL_FUNC) &_nanotime_nanotime_year_impl, 2}, {"_nanotime_nanotime_make_impl", (DL_FUNC) &_nanotime_nanotime_make_impl, 2}, {"_nanotime_nanotime_subset_numeric_impl", (DL_FUNC) &_nanotime_nanotime_subset_numeric_impl, 2}, {"_nanotime_nanotime_subset_logical_impl", (DL_FUNC) &_nanotime_nanotime_subset_logical_impl, 2}, {"_nanotime_period_from_string_impl", (DL_FUNC) &_nanotime_period_from_string_impl, 1}, {"_nanotime_period_from_parts_impl", (DL_FUNC) &_nanotime_period_from_parts_impl, 3}, {"_nanotime_period_to_string_impl", (DL_FUNC) &_nanotime_period_to_string_impl, 1}, {"_nanotime_period_from_integer64_impl", (DL_FUNC) &_nanotime_period_from_integer64_impl, 1}, {"_nanotime_period_from_integer_impl", (DL_FUNC) &_nanotime_period_from_integer_impl, 1}, {"_nanotime_period_from_double_impl", (DL_FUNC) &_nanotime_period_from_double_impl, 1}, {"_nanotime_plus_period_period_impl", (DL_FUNC) &_nanotime_plus_period_period_impl, 2}, {"_nanotime_minus_period_impl", (DL_FUNC) &_nanotime_minus_period_impl, 1}, {"_nanotime_minus_period_period_impl", (DL_FUNC) &_nanotime_minus_period_period_impl, 2}, {"_nanotime_eq_period_period_impl", (DL_FUNC) &_nanotime_eq_period_period_impl, 2}, {"_nanotime_ne_period_period_impl", (DL_FUNC) &_nanotime_ne_period_period_impl, 2}, {"_nanotime_plus_period_integer64_impl", (DL_FUNC) &_nanotime_plus_period_integer64_impl, 2}, {"_nanotime_minus_period_integer64_impl", (DL_FUNC) &_nanotime_minus_period_integer64_impl, 2}, {"_nanotime_multiplies_period_integer64_impl", (DL_FUNC) &_nanotime_multiplies_period_integer64_impl, 2}, {"_nanotime_divides_period_integer64_impl", (DL_FUNC) &_nanotime_divides_period_integer64_impl, 2}, {"_nanotime_multiplies_period_double_impl", (DL_FUNC) &_nanotime_multiplies_period_double_impl, 2}, {"_nanotime_divides_period_double_impl", (DL_FUNC) &_nanotime_divides_period_double_impl, 2}, {"_nanotime_minus_integer64_period_impl", (DL_FUNC) &_nanotime_minus_integer64_period_impl, 2}, {"_nanotime_plus_nanotime_period_impl", (DL_FUNC) &_nanotime_plus_nanotime_period_impl, 3}, {"_nanotime_minus_nanotime_period_impl", (DL_FUNC) &_nanotime_minus_nanotime_period_impl, 3}, {"_nanotime_plus_nanoival_period_impl", (DL_FUNC) &_nanotime_plus_nanoival_period_impl, 3}, {"_nanotime_minus_nanoival_period_impl", (DL_FUNC) &_nanotime_minus_nanoival_period_impl, 3}, {"_nanotime_period_month_impl", (DL_FUNC) &_nanotime_period_month_impl, 1}, {"_nanotime_period_day_impl", (DL_FUNC) &_nanotime_period_day_impl, 1}, {"_nanotime_period_duration_impl", (DL_FUNC) &_nanotime_period_duration_impl, 1}, {"_nanotime_period_isna_impl", (DL_FUNC) &_nanotime_period_isna_impl, 1}, {"_nanotime_period_seq_from_to_impl", (DL_FUNC) &_nanotime_period_seq_from_to_impl, 4}, {"_nanotime_period_seq_from_length_impl", (DL_FUNC) &_nanotime_period_seq_from_length_impl, 4}, {"_nanotime_period_subset_numeric_impl", (DL_FUNC) &_nanotime_period_subset_numeric_impl, 2}, {"_nanotime_period_subset_logical_impl", (DL_FUNC) &_nanotime_period_subset_logical_impl, 2}, {"_nanotime_ceiling_tz_impl", (DL_FUNC) &_nanotime_ceiling_tz_impl, 4}, {"_nanotime_ceiling_impl", (DL_FUNC) &_nanotime_ceiling_impl, 3}, {"_nanotime_floor_tz_impl", (DL_FUNC) &_nanotime_floor_tz_impl, 4}, {"_nanotime_floor_impl", (DL_FUNC) &_nanotime_floor_impl, 3}, {NULL, NULL, 0} }; RcppExport void R_init_nanotime(DllInfo *dll) { R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); } nanotime/vignettes/0000755000176200001440000000000014325355664014111 5ustar liggesusersnanotime/vignettes/nanotime-intro.pdf0000644000176200001440000065542313705546565017571 0ustar liggesusers%PDF-1.5 %ĐÔĹŘ 103 0 obj << /Length 4648 /Filter /FlateDecode >> stream xÚŐ;]“Ű6’ďţŞÜ‹¦Î˘ €HoÝ7٤śÚK.ńä˛[ńÖEQĎ©ÔL&µ?~»Ń ~Ť4;©«ÝŘ1Ah4ú»P¸Ř-ÂĹW/Âů3“H¨E(+µ§‰Ť4‹>_řôýW/ţxűâŐ—*\H$ÂĆ‹ŰíB‹ ÖÉŠ$bą¸Ý,~ZViUwĹ!}łŠâdůćfĄŚ]nŇ.Ç^|3˲Xߨp٤7J,›r_t{j!6Ďęjsó·ŰŻĺ•T°¦ ŽnRž7+±l‹şÂAŁ=â܉űxżúRHµ°´B¤ś ´IÜEóáf%mĽüÓćF„ËM^®od¸<ĺ]——D Xk`˘ ¶ŃB‘ŇCřaăutÇÉb5–҆Îŕ¸řÉađ缮ŇWßÔ„Ó»˘ĽËŰ®)Î!ë@$vŚĽźfFŤĄŔ™+ˇM €ż+aĘŃ6.ĚŽ&Ú&8[a ¨Ë<ů"?Ţ«(\v‡Ľę÷zË{čŇ®h»"ko„^ľ¤ÎŞâîFęeŢ´E÷0ťđ¶,‹Ş.&Ă›uZĄ«Ď÷éá»±¬řËŰ?ű!ďŢüá™Ű—ˇ L¨ŁČOŢűÓ$»nňş˙ýĹŤ —b€˙~=$ü€—ýIDŢžâ 4®ăqNůkVŽE™o<äk§ %łH ŢM8–úPYă$ ,l%Ń‚ÄĐ{©4Ű`Ţ;Ži†ŕ?¤¨y;PčpéľDË÷ˇ‰jJLô{˝:Ĺ9ݶ:ę›6ѢZ?‡žł„&C‘̧’‚V8:­­ńź»b“·Ś}Ěę}ŢZ@g›wÔíÄ:şüp¬›´¤ŢîáHÓ#Źż^nOUÖÓ¸ź,Ą'([JFě"˛7K –)-·˝˛¬‘á÷+˛«Ŕ)‰fcXTŔŮ‹(^¦MN}ł=nŔÂ+/Źuá¶C‹Šg;K/H´‚ţ.o\ÇÎv[…áČăű}‘!˙ö4óâ€z٧í/źV4«>ćĽLÝĐÓÉP „ŘĐ{ۡ1‚ľîU^mI OŢ5ÂĹS^çtHd“ [ŕUÚ‘’Dl–ÎěŞ= ǤEz:ÚAÜŹ;ÔU·é]ŮÜy—ŚžĚoŚS“:=qŚŚŔß}»Ĺ/fyô;+˛S‰mîČ ňMCż°Ű 6.~É9€#Îč˛IY°Üşůű0”UÎĂ‘ŘÝí$ÜDąpč*·cě»ĎË’jib·çáŰ4ë<ŚÔăçG{©NKçÜNhP±C<έ«qyZŐ€´w%ĘČuía§%.-$Ä ĘPŠńSš‘ô¶üľ)¶[ä+&vq|­_ë*o‘ňQD*„ť•3đ÷}ĐY7“´Ĺ­Óđđuę䛎Ž0é{ţâěTQv«˘z4źŁ „Äłň-2%+z<‹Ă±Ě^F3[̉EĘ›„ ¬E—®qÇH ‘™„†>źZî-*˛ę±ĹPƆÎ_Ú(@sč B$—Ű&Zť1˙‘‚¨Gř±ŚÔ š­Ĺ V>^˝ţ?ŕ8pć1P™Ňô}z¤ŇŇŹt®1A›ÔÖD”:ÖčHę"=݋ډ Â\Ń'éŘU3îňs»•60ŕŠy˝˙ůöÝŰż€RśCL`O{Ä*|¨Q± QŚí=:fc“˛9ţC &‚0śŮuň8Ů„,Шň|ăl¦NČ|A_ŃŃóŚCŢuí<Ź&*AŮ‹†^ŔŐĺ‰ '.Tyŕä˘ ĆÓ}lłS@n1CĆ"qO¶oꎑ&CB-Ç<€‡Ć˘ó#Ú}}*7Ś0÷Áö[ŘFă·[T“mîővŚ4R‚$e=JDYŽmśá×QĚŮŻÉlĐ yËź 1 öäŠsrqÍŤéăĹéyn}ŕ¨ęöTR»¨X‹Ţ_A'í›:;Fľ ż­ë“ĂƲčâzç°pptô)Ůâ˙ç,R$ŕŠÖ&â G¨Go'sškôTEařć,ň8ÜŁ"Ä1’nŤ IŚ‹ćÁZ«E”€e rXô ş9в{l„}LŁŘŐ.„˘ë°÷+ G+ ^’n­ít™ąĄ»„˘„ś7¶łÉŔůé.§ŐÉ,Ä#˙Břˇs ¸0FWĆŁťă€—ř¸öŘ®×D«µł$ĐŹŃÉ’T-ß0 ľ§‘ű”ß«Úi/d˛'+–˘Óuĺ÷ëě,0I«XăWˇHé—O’rřSÂ)čˤŁ%Ă8Í Ż&/ Ç]XždLŹř ö8 ×Ҩ@ŻŔá}č»ÍĆŤÓÚ# 7'aÖ\“°(­1r H|›HĆ g3ńžźĐ}›ďË6Ű—ďÁvî¨ó)9›Ő}’:ĎŮ/jr&i¬ đĘa˙—zI©G,=sVŰaף„!†Ŕř®.ř3™hĽEXĂŇgMµmOd`Ą¶­ł"ígź“q-p5 /’ˇ¦Č îć ˛‘#(Á/ĹÁ[ \)­vůt‡T0 Ţ¶Ś'ýJac” ^nČs_ŢĂ„Ph10¶›â’ŽčÉ´HfÖ\%„GçäłP´-‹Ýž=Z›Ţő>Ă‹Ş`ů¶¬ŰĽąË]"D.ŇCáÔ±ĘŢŇ'©č}ŹŠá˝ň¦_|>ZŹF;Jčĺ»âP€YuŠ ő1†T˛«°Ă´÷Ô3Jč(‰śP©í–Ęş¨ş{t2íKVlzxˇD;Á*ď„o>0áňăKłCĆ:Đ‹ȧeÍ$RŃtĘ3eM@Nhăd:wČÂ"5äö-˝oÁ@Rk¤1ř†›ÄíĎ=°×çp—’&ň“pWYk=ťŰźÝ:ä¸óř]Ĺ$p1±Ź1)îŇň &‘‚]DŮĺg Ĺ °$~ŚHćid´aÔň16}ܢ§Ň .°śy‘‹TĂÉW|eU1„(3 {<„Ö›L§¬ĚťńÇŃ€9'hŰVC… #ÇüŔĂČ4)ď0ˇµ†°ňy±›ˇضϢČw˙ÔľwzvŇ2JoŹX1<źŕJ#ТĐî˛=ä¨Î“,µ€igÓmĚPÇS_×›”¦÷ůČÓ9»­ĄžBy~‰ĺóşĚ× úUţ©Ő@ő҉8žH…âšK•QĽÉĘÓş)0Żż˛}™H0łÉˇäžO‹Ż Ćáä4%ń—ÂŹŽه}zřmDóéxîtZŹEuş"P:Ś%fÄpŞ•ŕikđ¤ŻĂ‘R1…óQ[=_mëëşŃ Bˇ1N¬ DOéŐxŞ?Ţ[ëł'C!´Y¶ăóKΠöčŘEĐľfĚ.»Ářđ…k9ˇ2j[3©˘şF ’Úň"_§wŚÄiÇß=;Ńęy¸‘v`-“»xtT‘|ĚU»´jg o 3Ö§¦›]•űZj‚‚]¬Ą~jüö›.$R;?Ď÷úX;;ťd]׼¬ł*PĄüIÎÓÎ2 âDLg\9IŚxů–™ÎĄ3n<Ô7CQ§Ą÷”\;Ć&Ý 0ýÝÓ_ jAó„WŞ3: ~rđŁřf[—WyŃ3+!e;§ÖNž!|VX;ĎX(—5´W:˘y’®Ęi3†vőpÄŁ" ZJ@&ł‡Ă‘mSćG4ś”ńšańäÇ@ZgŐ Ů&FMϱŘMć-¬áę‘î‹RţaOR¤F8 ‘„AzAď«q_MD–ď$¶E•ĺł“Ú÷RŞüXg{hDă˛iĽ‰ Wˇ€ż|őňöó€F<©Ä 0–rŠß%î÷¦4&lv¶9ÖbD/L*>1U6đ9®|ŕ'•hť†ýqVŽ›˘=–éCľsĚrŃÄŇ%«Ćő+›ľŞĺM‰ż+đÔI¦†­˛NĐŘş[ —¨ç7 ă(ŚN…Đý©ŐÔtʱAŃĽ˛’ŔgagxúË• N¶/·×Ýx–ĺGľ5‘^&WÚěNţöłAeňrćđ…1A”$*ŤodAĎřTk´ řHÜĺĹU“§›”Ş:Ö2Pđý_UZşŞ§ZrŘT0đ](BKG†^>\©¬đ‘ź™YŞĽ¤A§öä »ţ&ßć ‹˘!]ÚłěŚ(: tŤÎ-G'gŘĹQýő ^`¦K€ ¶ÖŹů᛫0AĄ_^ŁBě¨dŻ”ŕ=/hꂾĄK«Đ‚tătśŮଠó 3çC1w|čď{'gOšü7şXćóI6Éňxj޵;Ór·ź ăұX¬€¨ ÄaŽDgŤ*dńĄ{x3jk1»Ú7+‘Żs_ü®Ú®9eýáV^੣ÎÎcŢłf<±î>C`FÉ‘TÍW8·@éRŘ‹b¶OńF^Ţś…ążU~čë ˙tűb¦VJŘEvxńó†}µpcť|ÄzqżŔnřűÝč_„5/Źš:°ŔśrńB‡Xę‡ú|'ކŽýąěÇĹ‹j´z@*Úa)zĹ+a ŰeĐ@Ł/ôň‚cŔa@$ľű=Áoş=˝F$1H^°Ë1„p÷żç˘ďFkŤú˙٦Ň€ŢďÁdL8 "U(‚ą‹˙ŹŰŮa1‹żs‰•ŰhE¶fŇćĆ/ľű¬ôbîĚ.¬î~Ű‘Đ!a~Č"m± g`Ň–ëUhd Ż#8CČ ÷€aý‰ľ_DŔČŔšs()§#¬dk<î!ü™Đq(mŽţűě|ś­Ąî‹"Ţe´ĘÉŠ đ“ÎrĹÓ•P `ČóżţŻmępů“ř­‘>FÂ2ą őë0„ż˙éţťţZîă N]Ŕoćđsěvôٰ%Ú˘PŻ…„žäLŢ7‡Or_}“ß˙ýŻuóaΉßĽ›gł@ÄsTĎ1ăŚ#p*ŐëÜw1X‘5X ćŕ»ĹŘnĐßj1î~:°xúë`Č7­çä,ÁôWrý˝Ŕ]çFňě»îŘľ~ő*kđšqZÍęf Ľ¨ž?¨›Ý«ţ&ň.˙Ż©T=Ťąg­»Ů#.µúßţޏJ.˙1ÜŔĐ6:ĂŻ ř—oüű’‹ż~ďb«űčçě±+0ń9‡y^Đ—\’•j ± endstream endobj 131 0 obj << /Length 2584 /Filter /FlateDecode >> stream xÚÝkoă¸ńűţ áîĂ)HÄER‹^˝bw‹bQ`w}(Š»ĂU±•D=[J%;Űúă;|É”,ŮI¬Ťď6p,iĚá<9ś 7ŢľŔöJŕ$H8ŠYĚ,Ż^ü'€Ao=ňFq*“ŕS Ŕđyď}«f˙ŐÎ-•SŔ\/#IbA‡j4n‡Âd˙^”uŚ(K±đG8»ÚŮÎx2 ôřđ§Ç(‰‘zZ"ךőVwžú`śR5b©$L©yjŇ=Š™-Ěúwë®f€s ČA‚¨T>B¬±Őż?_=˙qs"+^SřJâ hňaë’Q"‘Śă „ 4ŃNůĂěĹĺ)‚Ąśň`vŘA‚2~;[?…Yʬ¬ÖĹ*?űeö·–ř傥Ź*€"ź4ÖĎ8Áf8Šĵ(ÔđŘŹÁOQB“đŠ)Ž0‰hz¦$~IčK Ăě‰pĎßt±Ř@‘XŠ WD”11;šyJ<ć#Ë}¤•“ľ=‹ţD~1ülů›Ůgícxîp殯gŰČ`Ľ5Âű­7DÚ"çďßķ |đÖ¸&ŕD^ÄŃĆ%””ŕżTIÉ%x† x ÚŇůćŚ'aUźET¤a¶Xä s;ŻĘűĽ,ňrž_Hs[Őks{]իƢԹ˝Y6•¸ą»ˇůâeGľ »¦‹Ž¨L$ďFÂačP|lGŽHwő`Q.Ňn°†zqĺö@”ś”ŇBĺ¤ô/ń˛}JüäX "÷†OÎŕGĎ?wcçëM]Ýĺ—ďŞrQ•ý€ůĚÁRGFř …Č §dÜ%|"ýŞčOŕcž^]×Ĺ<»|—ÝTÍ—T6ŔÎD c_ٞa·u _ĺZăłüf3/n˛ĺ]vb'‡Ś ĺńQąŔ6 “ €)ÓĆ„­L ÇĄE ;üÓ‡·Gbď¤í†n“Ź8H¤B{„’Ŕv“Ô¨SąRqF1$¨ďOťĚ¶ÇÔQK9ř+Űδ‚™^)ěľ:0řVĂĐΖq”aďáVW˙Îç*’4\äÍĽ.®ňĆŞť¦Đx"A–N?i|\CíZÓ´ÔŽáŕkjŞĹ"†mWŤI`”tnÓýRŤbśŞßőÜ‘D· ń÷üÓŻ˙¬ęß 4úłk(\şĹM^ŞćL<Ś{~Šţ…'_{¤a›#˘Ě(6Raç{µŹ‚a‰ˇnŁťšďOŃÍpDóŠ „Ekü5® w”OźŢ¸zŚ»ŚZ<¤µ‰n×Oď_$_»úvVĚcŐ÷a[Ť{ű ł+˛öó Ă3Řě¨eL8¤îŚşéż5łŞv‘şÚüĂ<4*cřţÍE®Żł^ç÷0i«(śçOŽvX4qSz3]<ŘsěłŃ÷ăŐěŐľľó>š~ţdú®0Ýfcµ»˙bjÇí¨{ŮĤ§ë^–=~şCŘLí»ŻćóĽiŞşiŹÍÝYůŇA6®ľ¨VwU™—k;V÷…tŐ0TŠrĄNę‡ć±öc(!mü°tďčţ®®î‹Ĺáóz ± ë « †JŚ{UĆ0x°Ęh‡>®ĘP˝BLďĺÝĂŕ#«Ś#hMTeÁÁď´ĘŘ© (•(|»6»e€ PWa&ĚZĐ+Ć„¨SäS§Ş`~śýe™ΧM­fŔ–޵‘) ö©Â9Ą‰Ż…xÜŽeç> stream xÚĺ[mŹă¶ţ~żBHŔ‹]3|)ňиą´AŃ"ɢýÖć®ŐČ’+É»·E|‡"©·“d{í˝¤íÁw–)g83Î<äáŕ!ŔÁWo°˙FX…„±rßB *‚^OĽúö\ę?Üľůâ=ˇ,(RQp{p‚$WADC…Áí:ř~‘ĹYľÓE’ŻŃŐŹ·_7, e(ÄEH )FJ €ŕ%ša¶0Ě;C 4XŤ2 ń„‚˝ţ-[G8ÉLDH¨>q~÷˝Ş®–4’‹Bď ]ę¬*íďjŁíĂ*Nu¶Ž ű+ŻżŁĹ”˛»}™dş,á9´oýäúÝŰďŘ~­÷E\%yf=%ŐfČ%ĎVzç™{ęm~E™ďgő$»łň†0Š‘ÜÎj?_-ĐŐ’¤·ž…ţűÉvĹQCYť:ëW‰hźýśĺO™˙Q%©{ďôýâlµÉ í¨«Ľ?pžd•ŁsCUÉV·“«_Ĺe™Ż’¸˛t•»Qšĺ™®g)`– „r0F’*«śZPIAÚ>Ô2J˛¨žrŰPč¸Ěłň­ŐŢ„EYŮWwzďKG[şmní-›Ř ţI|—jŰÜçˇÚÜĚMú”LľNźmźŢȉc·M6•}_îâ¬Ă–#§ţ5 ?&Ů›QŹŃé«AH‰¤÷üŐ&Î4jL0$ D$"Nc_Ć«Íܢ”†•}šăWeq†¨›e)µ|Żňí./kź€_µÇ o4xŘĹEU›LDµ†„3LMŤťÖˇÔV¶Ć&B´oĄ_µk‘Ĺ_ňJ;v›¸ňOşÔɲ:pŚi]„ 1§őmül]x?j·öv0­¤rżĘä!+'­ÂÂŘéčý^#nDČu–h!fJÜÇűެŠýŞň}Ë笊?Řç8Mó§Ňµďô*ą¶nÄéâYÇ…{eőOZ˙\:wűĘ6«gׯĐy »‚MŹÜ ='EmmS\HćNq‰‹TŤMMśđĂŘ´żç|yűf0ŹŠx°ÚľůgÝľ ęľ°2aó)0Íđů¦óŻé°ŮíGŹv®S¤ÁŽŤ}`לh5ýˇa3ÚĆű{đ&ë€ Ž˙˝m›Ŕ¸÷ăĂ‚|˘ŐÓXÎ]ŕY Š‡Wât_O˘QdG—ĐŐč…J’ĐčüUř×aŰáŐ¶9é<úoŰÁ{bđŃ Ü†8ű›żÝçŐ6¸Ô0akRŻ:ą‚}#ÎlĆŐkDËł^‚{0_[13ěëLFťđk»JPdL —¨x»IX/vC.¤hÎŇý€9¶Ý#&ń«§F­Ś˝úFžÉ–<‘őĽ­?—đOö/ů¬ÇŮOÜđu^ÉŚÉ0±Ă÷Zľµé"éHşt˘. AŠs+đo®–d^|O~ĽZrĘ„mĺ¸4=aޱÁ@͸ĎůHýrŠGô{żŮ&ę(÷»č¸¶ůG:ÝőZ,)aCíßśŔąÖĄ §CŢŇ8–]MÜkůXmk("Ľ–'Oĺ#…"(?Ühäü)ş ~8ÍăĽßř†Ď…ť„…G8úŇ­;#B_ţ‘ÝŻmů¦ oKß–>Ŕ}tă ýdA·ąŤNvO]¶›Ş«»IžKZ¸ |K;ťw«”Kyávđ{ČIFK.lÖÎ|& óSf‡µ};™Í —VíŠü1YëőŰYBÉZ±ËĄ ›”’î^B0Ţ:–&4=OJ”É©ąúŰäxëyiÂË9]&Mx9˙_kš0LÂČy› –Š]ß!CačÖ,€ŇĆŠß.ŹŢÔĎŘ !M—a›ý)ČÉ„¬dr*@›«dLëÎŐXéĽíÂŤyh»xµüinŇC”ňËNÚŤiE“–Ż7góŘ`gs“'Ô0P—ť˝tŢ懳ŕ©<ˇkÎJ^QBŞŹR™ÎÎß ÝL tÓŕÝ!SFÎďľÓű4ÎQ{DyřVa›opŘŢC u‚8,Lk >í@˝ţ¸“81!vÇJ˛JĄÁĐĆŃ·FEHŮ#ľ™ĺ&)R˛O°ĎÜjăDÁgM>Ř%txö/ 3ĂPtI@9ëäţţ 7ˇ 8Q}n…S°ĎžjY)Ţëbíz’"yČ‹|_zś7[§ ŢZc‘HÖ}qj[k<Â/Źĺ©AŞ Ţŵś:SśD=:“?ę"Íc·ža˘îÇžĹ8đ~»UßÓN›Wc4“PGĂÚśš•›Ľ¨6 mĽ6YíÓ¸HČ_î“Ęťąb×_m<ŘżżŐ:“5Çpö|kYB¡][Ví‘Z<şÔĚĽ-„×q#Ëű˘9ÝoýˇĂ’)č'ąîµ/¤›ŠşĚ·îI·»T—‡jk˘ a…Ýôbµ5d0˘2”ŃÍcŐuŰő¤ňÚ…‘búr˘ůĽű^—)±Ď‘࿥Č&WTÎŮf›!°WÚ’ !ź˛Ćf ŇÔŘ«yčą”ž<Ď:㸪>qůĚ4oÓ,|qM ą[bźk oăĹň÷VŮđ:ěľ^ŽÖů7/.ôťř˝Ř÷ §ÎíÜn ­ÁÝ®ş*˙Ă*ć­/OÝWض EÔ ˛„~Rp,B8úÔËhi—…Ď”"ÁŐ(Čľľľ4\ÖŐ»óˇ^I29ńľşĚÄ!ĐŢX©Árçˇ'nđy𤣻ŰZ9F?ăëĐ…˘A·áQ×aA‡pS#u2ťś]2]_k ţICR§ŻdH7řĽ!;{É!CŠKRĚ2:N&y”Lç˛S¶Oš˛ź{\Ř”nđ‹™r|é^_~M.'Űë»×P&öJî5w˛ĺ˙7¸SÄÎŔÄDH­™Ţ7V÷šë$jüKÜď\î6~&)íěˇ}‘T›­®’ŐüĹnbR«/Ą`,Đ… ĄĹ·&‹˛ŠÍuęµůEúò˝¶ď↗}ŰQ’{Żí‹µ6s3OW+ćÁÜĽ­qZÓ©†Um{ro›jő›†§ŤÎ\/{•Ó46ěZn5.ÔÎĚ[ŘXÜ/+“»´ľ‰¬đâO[k!TeO[5Wy׮ʇ ý•ű»ŞWUX=Ç $H4}a˘3† ö)ó➌B1Oú„ÝS±9¦‚#ŚyźÖCtÍÝčű"ß!‡n%‰ú™ Ű_žÄśu™ĺpúěC© ŐÇ\}^?Ă•3‚„˘}Zç7ÍFŻm!FÝ"˛®c€¸´Ć9Í•Ř}Z%;Ź9¶—b“훇±ž ~Gźös´Ŕ›~S€¸„-ˇ©UćĽ 'ÍpöŽ·8ďĽô\\ĹfŐB‡îő 0ň‚v¸„a#9¸Ö;Ö8z«×uśqďš«„RIBUŇżć:Úę@ĎţE áąL/ŚÂŽlNµ~©[»…B“ĎÝÚ%8‚ ŠôPł^  â%†9jŻ °·TÚ_ď¶VńÎËźŢe:Őĺ*pň}Ps–KXsćúä‹—ç\%˝€§”:9÷ţ¸…€Śó•K«ó[¬¬şÍ­ řB\ŹÜŕ<»˘ű…śÉŔfv×/Ćžě9„›˙D.á9GßvZ<ę¦O}Ó9zą&ĂWąLĚ Ä2AÜ”jĚ(oű<®lÝHŘáÜ,n·uWfÉŔ€>‘ęTYL@%ăföĺz­Ó»+Š{]U:˝±5ÖwIúxóÔe™ዤΰB ű´Ý+Ćí˙)ü[ň™1 ?atńoźĘ°ŽÄ’†üëšmzĂ?Ű!(qüŤ~=}w EĽ`”…D> stream xÚí[mŹŰ6ţž_!lżČhĚĺ«D-šą\ܡw@“-‡^Qhmy­‹-m$y·)îÇßđMµ˛Ľ^;›¦(°‰hŠäĽpHÎ<âŕ:ŔÁ›gŘ> üŹ1΂1$˘`¶~ö!€6oÝđF,‘"¸ T5üýĐů_5D0ü[ß+LáśÄÁ*x&0C’°îŞV= b9܆üWđ¬čđ€ĺ Žý6®Ň=-ńH WzÜtI`”ÄÂČzB -B«ÉŽ2ˇĄR<â‰$\)ýSסÚ!µ­łŇ)ş§iŕ,‡Bç@ *•Ő;ýzî;ĺŮ:čY”S™—b“ ‚ZżćíÖF§B"ÉX0Ť¸˘÷—ËgçßJ‚%Ť‚ËE`Ĺ”Ł—óŕ§đ«Ż&SAE8O?®ňëec~Őém^\›r“Ż3[ŞŇ˘Î›Ľ,.&?_ţ˝Ă(aJ­‰bF˝`ôü;w8ÁÁ””a¸¸YmjoHŕËN{ öFać˙Á›ć‡S†é`nś´FEZ”ZÂ1ę"†±řuúG‘žGj¨{5@ÚźQLńł)ŽŤ ˝Ŕě‚ĘŻ1ľŔřĚ#mĆ'Ď+‰(2íIx“Uy9•1ŠQ’GËHćŁrGĘĐóŰte;î’†sµč¸ß÷n™Ď–†tne(«yVe–Í++CŢÔN´jĆXtşÇę%[ť0Âa"“÷ş˘É4Âqř·"Ľ*›Ą)iFjS6j‡Böa“®žC9†JS5›pë&,ˇPką\oŰ \gvś« ôo‡J őÔS\túh~d—v9¦Î(˘ŕ{bŐzŘ=$céwlEm–¶P§ëĚŠ u–kőF‡”HćĎŚH°VłnÖ®ŠÉ”J.Ó`¬6?\Ą&Ą Y1W–‹í›Ń)‰H¨OrĚşěRŘł8ě^çç†î]®Ě@•Ró¨—eŐd•á./ ¨„~"j7\•Ýwz®JđŹ*'p†F§2ŽŔéIîËłu Ç$ &sż{yőßlÖhÇ˝ż†ř*ę ×íć%đ'!(Ď–émfJ©y¬ł´I›•ů­˛]5ŇsłĘ©~VŮ:Í SŢvńű[d÷1śqAa‹'Śă‰@ ¬9ęĹńĂŐq|ŰtwďžťčVuĂ2‚Đe‡«;aďrO(bZŹćOĚÁď% ď?ŕŢ đá ˝‰Ö{đ[ÓHń# wĚ~Ş ÷k0q™¬OŤ/T ‹ÍŻ/_YżďŰn|ÍůŽćÓ“Ć)TťĐ¬Ť‹żéyćűe<Č‹ź2¦ îÇO4Ó'ť‰GÄ6ŽŹ.ßţřúÄ(Ó°gĘßËB{rR›ő@Żo^|Z›5řËqxŘtDOkM„*9’§7§“@7źÉŞZĺۧ0Ş ‰˙^l ¸ˇ ß~÷ňűw݆Şúćä†M›¦Rb??CďŘ«UZ×g[!N0~Ëö™ 6 €řŮ1ŽďńĹ0ť8`' Ă©rŁżwˇgĹLÇqř&+,~2ŽÉ¨ *v Ś ‚m·Ă®ýa% ŻŰaÍďĽ6Ď›ŞĽÍçŮÜüÚµ@ÔÍeŹÎľŘŐ1Éx„’„řťU6F0Đ–ß'¸ Űéä8A“~gZ"DáĺŇŞ'/fôe…Š#% g©US–«ĐĐ”Ż |ĐA#ÜlBHO$·ŤÉqD˘ŘďĐßŔĆŔ7š¨Éë^*î1N—đ–ŇáÝAz‡,Ĺ*FďŃ ‚bĂwą11Í~Ř!uY[<ëLß»µ-›Ň>—®B TĄßĘB—˘PŕPcá8Ż}‹1Úúô}f)ݬҙ†~0nź~ Ž9˘Ôŕ|®?<¶ćäűlâÄťÍoŠbжMZ]o¬)řaSŰŇ•…:ëMáĺŕ¬Á43ŮşAuöa®Ôg±is§Q.ŤpŐ8ٵ)˙,$hű)o܇(ľmëźŘ§JĚô@ˇÎfĄV˛_ÓőÍ*ۇžPÎŕ$HNžpµVbŮOk±×ň0č„+ÍÉőŔ„áę#ˇ“#hť:9‚?tr!B’Qč„©5ç<=»¤wúŞD (!§ĘJ Ý•ţř8ő°ś„e!XG˙ęă‹c,Â0ŠEŇK`řěßÇVĹ*+®›%*7Í‹?Šßűô}t Cc䞀`k—ZđgSü×I˙őÉBÖă„áqRdžđ.đßË˙ěJźmaĚ@óŰáH RŔëMj>˙|ľ˛81¤K#‚Iľ¸ HQ¶“Tß]ę–ý˛˘Ł[=Ü7Ó›â+Çßžö»Žž4ÂîOš˙Á4ÝfŁ_ÖÁ4 +Ž{éŁU^4ăůŁ‹“çŹ>čřđ¨ŞŮú›®»0{ú=wýçž»gĎýCl˙ěDEăăŰ˙ń[ÉéęóÄ}žČž¸Ď9ާhÇádyăIěĺi'žß ŹÁóďaë”Čbë}đ×­ęóŠ (śŞĚA}˙,…Oń8l–éhľÔÂţůÝ÷ç4ąŢô"Âď­‘P =+«*›5ć‡MŮ‚R•Ő7mµ†GŐÓ ˘P˛¨¨ęź®f›•ÉŻT‰_*ÁďVcđ˛,ś|¶uĄSăTiYn*•|©ĘŞCcůąS™O¦ÚÎíeŚ!𔂱Řaϳ٦˛ ŕ˘*×^ę•ĺJ–{…F.ufQ+ĽNòŮ[ŽG(ĎóĹ8łźEŁ“G î2ĂV‹ IÂé0‘}đ$Á âô„đd˘X! D×Á“mËŕIčEb!ąĚ ×N>žŇi ÉÇÓ˙#“„păq`R}ŠŽ˙</9Čă%_ě=-©3žŘD(J/:ŢÉË:OĎ_•«r}UëÉM-§žor lĹS˙“ąůÚé8Ć4xsäHßźáű÷µÇzŢ'µ›ľă©č“1vĚ%;Ä$Ű‹ąwéÖÚ×8ęŕAŰ×Ě{ý đ KJt §Nŕ5qŻĹ{čĺĄÎ˙Ĺ'Ît|¬ť‰3R ’0ŁëO$ł´šDXßeřʞ0~_ěrűeř×tBqřQ5ŢźQĂÚ„ Ř𢤥§ĽÝ›|~±Î4ĚÜ:Q7$ş)4L§ĐčByŐ¤yaŻY0ó‘ZsuŐ6_§Ť)Ű;%LÝ™¶—/˝7wYöŢ”Ü^şó^FDQGžjÓţĺNŤľďVLEĚ}ńÍ~Ňe‡;F™bÔćĆ`î{Î1óVš!l‚€ ×nžä^9†qbo-Ćz‡]`÷xpbéǰC Uř?zŚ= Q•ĎDâ{ ڭɶŚ}Tćý ľŁ Nč{|é!ö°Ĺb8¦#ľ-ŮIKÉđ:żÍŠQŰăpŔŔjď33rß­ĺ…KŘN“Ä뫳µpřv x]g뫬rŠŇkGłfŻv%˝«]]Đš°Ťa'°Q#”L" Š+S¬›˛2Ë{ä•BdqáQŰ“×2J¸Ô<ňúSx{3éąý]š§˝é%{ĹÉľOW«¶Ł),6ĹĚ^ÇÔőé{ű"µ5m¶ŽŞŰ¦/É6ĘŰ1AŁ0·qâ-ŠÂ*0µRí.Ýö:\vŢŕ˙ś+D:ÇĘfoľ}łçm𾌆˦ą©/ÎĎgŐ„€ ަ“©$jgVéJ¨¬®ĎoŇ™:ާ×Ů ßçgŔů-ęćˇmţđëů<[]©7YÓd+»ĄĽËW·8׳şc""ĚűŔÂ˙‚FJ” endstream endobj 156 0 obj << /Length 3088 /Filter /FlateDecode >> stream xÚí\moŰ8ţž_!ôľ(hĚňU˘ŠŰşwí˘‹»-Ú¦w8´‹…bÓ±.¶äJrŇ,îÇßđE2ĄŘŠó⤇ ZEr†g†3CŞ88 pđÓv׏^Ľ!” §Áń4 ă^  )’ ¦Ĺ<8^źĂ:[¨ĂŤeř{‘›»8,Ő×UVމ-źĄ-®gYe‹ĆĹbąŞÓú„Y‘ŁĂ‹qřKQ»žęĽrMTÓ"?Wy µí שljÄá$˝´%Ĺ´×öB©3[ÔĐOíă¸Xĺµc˛,¶»~ űąN˛zÖTřőřgŁ ˇ(–Âb2Mçó,?ŐŐ“Đrś„Wąf‘0"ÝC‹ůëă^g"HŚ_¨÷S`*`Ä qčbř{ďýęŠz‹+·„ĹHF”ÇÁ<8! %t[±nłÍUˇËąÇF”'ZFÜu±.ŇÍ"rC„*[J›6–´OŁ$€=PššA´XzpBU =â‰$\Ăľú=˛­u™“ď¶ąÚ ŤôPh 2„¨Ô’Cśů÷îÇ‹ 'U˝N›kÓíHpÄ\bŚ$3RiÍ–`&’FÚLŘJQB%,8žhÓE°ŔáźGVŕ´T 4(L·äÇ‚^§~łu;%P÷Ĺ{°HC ­ ń´ByšĆ<ůÚv…ďzăM«/ŔîÎĽBýg“dDč‘Ă‘ "¤ř%ÖĎ:Dˇć‘ëöúaźMOőď?túŘ•ŁOÇ˝B†Ev¦ßu”pD@ďG„ D‹“†ö· mφ°ĺ1Â1ó±­G7€×ŕđěŐŞŞËtžĄ/ţˇć'ĹŞĚŐĐE¤űŇJ†‰í¸SbH(ńGčřěŚđONv?“_í̲ŢlÜHü.T™ŤÓż¨‹ßţ]”gŹ˝/ü"żĹá7µđĄYYśdŹ"}dâ·(rđjÍ#E ó»â÷6źdiţâZĺŕÁÝ3~ŽĹaüöߥJˇľ lßŰňlUWŹŁąâ.|ňĽp±@˘8‰Ť^8OťĂŘbÜ'&Ćďg”…ď–ŞLuŔRˇľŚôă+ęH. Ľl{ŐÁıc!át•ŹMş»ľ¤µ> –G˛Ű…ÖéĽ(J×t4bcÖmťć“AŠę2¶âXe& ¦É¸D”&=šĄô˛,Îł‰%Áa–ŰҢś¨ŇŢę8ÍTT%Ä„ [Ż\Ď„W%ÍMäŃ„ěĹ[ T…6”O2p7JLŇč«qVą U$á«| „*Ý‹2;ÍňM xŚ8A\Ň'§«…2*0b˘Z QíĺR N‡€nµx=ůŽđ<˝„u™§ąĄ˘,ýb©e\Pµ€ľ`ÂM¸&p6 Oőé6ÓŐ|n !ŚŻËÂ=çMŞCQ© ‘ĘÇjSŚ-Ôl;ĆfEĄ\hí’Iň'­ ۸d¤#Z°TT '­ŠU¦aä)™‰őŤęňt^ą„€M 8@ŕ©˛Ş‹bbËłĽ“~°cVß\BĂ&'˘đ\Ťë˘¬ÚÂe"B`Ł;ͨ?ZŽ!c˛Ű¸8ůPŻ,#3UŞǭл̊Ňó›+×"m´(ˇÝůá ?‘pósZfIZ•çéܤyâlxă-Yx‘1Ël|fďR{)UZÔťĚUóÜȉiiĘít»yvškíqTßć®ç´¬łńj 7!4)¸@H˘«^±E ŕî¤!mW.›.M¬ýЮƳNż6Á™h0,óE ‰z pT¤Ł şo†Ëťů±÷z¬Ń–m˘’Z‰9†Ő c_Zz$Ž‘¬K0C m1Lë† C“nĂ–=2ŢBĆd"ś¸T3m˘Ű˛·řČ^#w%ÔŤ-ꏩ%„ă]–î*3¨î:°Â"ĽjvI·/«-NgN‚_dF¦ľ-çŮ8«ÍŞ)ążj˝1ťçöť•yá´“7is¸#şRMu3r٢eÝ =kú2˘Ż@řÁîYËĆĂe‘宵łśÍŕ$÷–NТDkQ6•|-’żm ŚäŽ} ­ęM‹9gÉXş‰/6ÚZ-0˛‰žt2Â@wQ {)â—o”4mťyÔ4uŘnr¶)e#a‰“°¤Ąç,ťGB7¶MĶřşŚ?  p~ď-ăO)_ŽťÔţ–âM˙uŐeüułHr–tSŢ[Šď–óż ­űÉúß…ď5ďżKr¤ż7@q r,ÚXą“:±u ěF żNź´é ˛O·Íb:ż5°Ů`!BQK[ľ-at댽cĽ“Őqž¬lRbpŕ±D\D·8v{ ଑Ť#»[Ί0˛“rVüc÷熱}ä˝dÇV\#ŠbmžÄůöâÝRśĹw+Îŕ'rq+qć÷&Δ!XBţđ¦yOLŔË‹$é rť)Řn0b°twÜhËfôÍFłß é[¨ xĄ&ćßYg´@<™˙'•ůŞ ™Á˘»nWyܬzOKĚ>ôe§{ öŻBdń¸ĘłçĂ.„ $č®ń&Çďcń‰žź'eú˙W¦Ýcyqť.m;”âĺ¦ăPʶşr„ĹK+·GXL‹ŮEo±X –8ň©RÝď2ś¤uЦeÚôwŮm÷˘NO çj×S.@U€lˇĂr·óóĘîa4 z)Ă\]¸’ËĄŮy†˛L¬Ćf« ^ť\®Ů]Ž}ší™°iŹâ5;čí‰ŕ–“¨Űv™ŽĎŇSe‰Ű#Ň~Ôۣ֙N,€Cűúq„"Aş]{X3ĆAqÜm|ÍI.`ę%ß@°6;ëĂ(Ć=}{–čş®5&íŁµ$+.`›fϬ·˘“!»ÝÜŹe–gçi•ćŰSÓ4ŰPú€öF›e7¬ěQł×%Ă/í–Ő,=o÷ĘŇĽŮÚš(ýIËŕŃ ĆDvqÝŮ›¶q™łeťĆăbľZt¶ą·-¸r;l*­Ü¶˘9›×ćĆ‚{ \Ś*0çŞﻦ†=ĺÓŮ…\UÇŚšů‚H\pOĄ`ľć›†ĘˇˇÍ2X­N*U×ÍťŤ±¤ěţöĹôńź„÷żxŮ\şiW¬­9´)†ý-"hqŃűdcˇŁwÍ.ŘÝ:żŐ¶×ÝHŢó>¬_qB÷ň…KLöWË ¸p&`ůµbśMľYĺ1>p©Ô×AÇ“%äľţťĽ}şËŮť˝}Lźßc.ćäň‡»Ć^„ě‰äÁ“Rdr?ĚU~ZĎP±ŞűP`CP˙HçşwJ,˝SŕßËGMŕć&’n1©T7 b˛]ßşNŐ \`QnŚé9ąŐlöżĐžb‘­guJ6…÷/oĚĂ4<3s˘vNď¬ď];žKŹ{OÁŻŹ‰őůăź^oď.ńľyő÷ŹŻ‡¶'A=$C8ę}îa<¶Ô”îâŕlhă6Ţ> stream xÚĹYmsŰDţ®_± §{éfBCJ ™¸Ě2ů :jc°%#ËĐňëyVŠă¸ib%5ÍLśł¤˝Őł»Ďííž-IŠd$%ň‰”˘„˙_đ±řĂŕđ‡›‘T’ř–Š4ţŚÎ´&m >¤>ŽtÄó@FK|%c «6Ţ’Qd">†,TKÖ$2l™‰d#Hrx§Uä jťĂK.J˛ž<ŔŮ@žU,t:I>zHSP!s†‚ĂMG!:rž"&x„ Fâą×Ł… ŠÉ‘w”4ôzJx§Ź”‚Îŕ„„éA‘’ĘS€ýŇ`„/¤xFŘŕ ĄpÍ>ZÜRŠő˛ë s”–>‹ěChŹěDü\4@84Udwâ9ܦ`<¬5n&Ŏկ⥠NZf ^Žxŕ)ńÜóПŘçxy‚Ó­6Eă §$Ü$áţK\y ÖfŠÝ*Oç{„K!âV±( ´šăYŤ`(ĽŃĚe1ë ‰y‹Gk#“„ă˝Î”š$a0ügŚS0Ü&¤q§€YqĚ5ßá¨2ăśAÄŔ‚YPă¬gĹÁUP 28Ź©žěbčK#f†dĚ ‰°+KU'ł CĽŃĂ‚( rŢKťííQ>˘üyý˛¦ü€žÔăŻGmŃ´_Đ·ßfOŽfói9+«¶h'uEőj/JjËŮĽnŠ)µďçĺâ‹mJ^Nf%ý[WCD·h^”cňĄP˝|UTu őĂ$'Óa’ç˦łxôĽl&őůvŮQŮ wŞXw¸¬ş *Şóa3u?sż™´ł˛ťŚ·Ë>«gó˘™,î´VŻ,řkYVă’ž—UąŐE—“~+‹ć+úą®Ú‹ÎâýöI'ő˛:źToéĹ=ĚţuQŇ?°śÎ‹¶ošÄă7v—mńzZn×qTÍ—m7ëŲ寇u3+Ú;&šÁ\4ąhîĹEs.šŐJ_T“1–ÚAŮ“ébű”ă˛yĂľ@üo wŢăbÎS„˝¤Ër6+š÷Ą÷çó1wCü{‹¤Ę'í‹îíeůKdĘŹ‹·e–?·¤Ľs±d–ꔋzŮŚËE—Á»[?—ç“â»úťJÜđŘ“CŇgT4‹Ôźząý q\Đ)¶Ńî­ŘĂşÁ÷Cč‡ŘÝŢĂşAőî‡t굤^K굤^K굤^ ď\ýŘë9Ë6Lípeůhůşí®šTfůwus^6ťIň,˙!?Ęźá ÎŘ ă–N±‰ŕPF¨ nŠJ4_Ď›ú(uó6źă?QL~sU`<ÜkŞ»¸˘ĐčŰ{ä.˛_żé±9PŤ ëZüę·ß‰=ex™zGŐr:=»MTő˘XáuđQ.@´MCD»ťĎř!˘Fó&5DRXĄě Qj [ÍuQB/0­›˘YŇĺ”ă˘m˦˘ľ,Ďż×>µHęÔ—ŮY~öˇ Ă!źIwŮl UóŘŐ…«+>Š—W|–$ÓęQw $WWVvG‹—W’OŃVÝ Ç(µ~ź¨ő*aL~ÜÔc>18…‡”ż,ßµö¶?FÝhtz`űĂ&Ţކl_°6t»Éĺ‚E‘ťřîł,Xđ…Ł°&Śyë¶ł)ë;Y—P(ř8HV+,/o‡éEŞt»¤ě&÷6ůuŤQ7 ĽAîM&*ŮŹPýÁĽL7xi½xyÝ«qp.Ü”˝L[ĄźôdUŚ`o& ˝ň#Iv¨ě'ňŕÎlµA‹MĆ|Ŕ‘Oʵ 7bmÝCsµźšř€|ť2äçËAÖĎA˛}®đÚ =H’·b©†iE5)¤O»ĺŢuÝ™‘†m©ĺžó7¸çěCąçzËů·’ntf—ÇrN‚ŤüăľCx<˙~ĺ&ݶt×N´w×)÷¶Âú0ŕMrÂňŹ‚Ýa4÷Ćór|U˙ endstream endobj 170 0 obj << /Length 2644 /Filter /FlateDecode >> stream xÚíksŰĆń»~ĆŤˇ‰qľMó!Mm·ťf:¶éqZ;“@D˘%+Óß˝H)‰„l5Ť‡&ŔĹŢľďnwqÂÎĚÁΫlŻľ±C_ Ć™#Cľp¦‹“_ŔyĺhÄŚX(}çÚQ`řĽn}+DDŕ˙bë–`‚ç$p2çÄÇ IÂş ¬F`>Ś $ß;'yKŚ(qĐĹi€ÍŐrđţ0°#M›FaŕýÇgt©UX[˛eLŔT†G<”„+Ł?ű·-®-V Öms5MäPěřJ5Äş_űľu?]8˝ęĹźçK$s<Áŕ†+Zšś<I°tB *śÉĄc‘ĘQŔťIě|păúC:űaň7PC9Ä„b‰ť8t!o^E´2a ¦ušć§†RŁ1bjĽĐJPC±ył±J_V*ńiC:˝Š˛¬”ľ‡)'abhv ZJBI‹–'( Ŕ!(ô}Cňggú®Ňßó©ď^‘3ŹŚÝ+ÚSăv–€h¨‹ uěc—śÚSěaîa‚ńąţ|Ąż-7h/żůűۇ3÷»ĚiźąfîŰëäÍ»ńł>ó`ąxÍyŹ9Ů6»zLÄě~źąfţ f}ćÁ0óÝf·×“ÍîfÖŤÍÚňzł~yzóšěµÓ^çĚ'wÚŕÍ’eöLołiš%‹rş°äR5ua‘ĚŽŃP:‚`FśÉÔ~W%0i%w‹KuőÝzne±Ęă4ź™_—«|Z§E^¬EôsR™'im®Ë˘ŞŇ‹,±d MĘˢ\ŃlV&ł¨E§Č•íúkWŁ"“°‘„¤+qŐŞ#ĹÉ Ý©/g`UŃS8Í«:ʧŤô«:ÍŇĘŞ kY]5Ú\ä«LńXËăű° †ŽŔ!bJREď§jé]Ü<…Ač qTĺ^’"fMľ¸R€Ŕn(Ö8çťĐj‡”q>,ŔŔĘ<^Ć$9’>YŃ͆ÁÓuwĆÔ\[y„&0粗4 [ Ćü–¤id^äM#KđHR'Ľ#•_§RśîďĎĄ|BÜH›Ą4™Ä=›«Ü=˙ÁH%R°\¨µžÜä¶ě«J~éL¶­EÉG"\OĚŹ°WXďÍLľćU(Źň˘NÉ^î~´ř÷Ű-řOĚnĆ<,ŤßMľ}Ňág’g‡ęD°Š\ů…Ô"x,µ`?&!覣7_÷2Śű[¨?Ö@ńŞÔŰá^#q•ľh$•µH\-Łţë=R<‚ě’ť¬(®żÜ„ěnô»C"†;!ËČ=ţA+őý‹±cż¤Í ;c[Ňtďlx·ż›ôn–äłzľ×D]»ZőĽPp"ë{˙Ă3ătŻő†.’(?zĘزÓĘ­HîU“ÂŢO;+tÔ(iŐXOăűˢ=µ35wś&;Bć¸O&­ÂáŃŮź 1IżÄ"L ´s 9˘ąŔ Ďa‚—c€˛vÝ“juQ%v9ĘW‹¤L§OƨúBl:ţ„Ą0đ·ĂíŞ˛ŰĆPűđVU©;'yŤÖ:ˇ<Ĺ@H‚üj[h®„őLř\ůW9Ŕ5Äcrőű\Ăá^cr\ĹP‡‚ŽÉ5ŘćÚ÷«ćM˝–\ĺ6WĘFŤ¦°Ç•ŕAżŇ`;šv6ZŐĐ1Ý=äz—€Z[ë#¤ZHM†2řčÍçµŐźjő(lŠ©.‡µ­Îß  Á–5Žřkľ\©¶R Ý(ŹÍÍ?Vőř˛(QÝĎŘQń¨ŃF‰‚0Đ˝'&B&69‚.€<Š]Ôßť»MµŐłÁ.€°:,€‚ŠŮ&ÓD5ĺenj Ă(7†Q°ÂFÝ_Ăčű8ąŚV™ĹVý8üH);ýçˇëť.ĽÓxrú—óÓďÎO_|˙öôĹŻđÄëyRZ¦uĂý§ďźjŐ2™¦1᪍¦žDćr•i“°·•j| ŮF%ŘÂ/’ŇS˝G*Ngş§` ‰•Üp÷µ=«dZ˝U‹®Ti‚ÉH„ű~žäžż¸JĘ25-LKŃÚ†»ie9&J‹<‰!Ad,hń–Qą{ťf™AOói¶Š”<»ŮŘéZu}Ś dŚľe’%WQ^›.a+6ŕײsV*…Ó?µęęĆôbáć*™Ö đ:­çĹĘŇ)ÓŮĽö–Q'±üš”Een#{­ćŵ%ťć=Ę—E–צ˙ ?“OŃb™%·µ)‡ •á/j!”fSďEí xřEmzż¶# #ŚŃW9>˛íxŻ‘ÚŽGHđHŰŽw©˘¶Z“”űPr„ë-©Űž3H Š- 8z-żÜŢp¶ŠlU›±˙ĺţ ˇđYg:7˙ľÚ_ú^ů…ÜVř Č6$цîĄ˙ŹN†ć±:YÉö»ŁGt4÷Ĺgs´¸§ŁA¶ß}=®Ż>ÎI˝[¶ÝĺskÇőđD+“8=Ń*aěá (źf¶†ůsRGi¦łlfPĽI­7µ® ¦©iŐj„¨´Ë˛¸JmĎŐą µ„¸ÓŐ"ÉëÖP["´¸­ň8)ł›É3÷Űo'˙2(YzQFĄ%jčD]ŕPëfBkýÓĽQßĎÓÚRWĹćpMG!0Ěmď RJĘ^¸y ÓN\ď嬛.C Ą&P–¦Óů™&©k8ĹÉ2+n”őÔ–­żJ#˛ĺ8—ă¶s›|Ę4 eZG“7ÓĺR›pčĆĆ4T/ {c—Ńôçh–śÝSńPÄe«¤®“¬o€gwóšR{—ý Nć\6u2H¦ëdĐ©“ľ®“áŘXąŞ›Đďúť€ć„Ú‰Đ.Ł©$Í!"¦(›Ă5Äťë‚nŞbaźĂ0ś|J/Ň,­o Č4|$ޱ…˛"gJ~ócŮ› ű´X¤`»e˝ßÄqŞŁ Ęt¸ۗ­J@şÍQJčŔ$R$CÚU÷éĐáµöŻ_>ý8Dł˝;<Ýqxicf(ę]Ć[*ŻŞ$j= ŘxÔg±TŔ(ślZM;EýÖçlÇŔ¬eˇË´-‰ű¶¸SŰ j:Ş_˘ŕ~;bZ”e2­ł›Űz BÖb#¶D‚qNz­…ađ`kaŤşŻµ€;…6 aęTŻĐ[¦·ôŽgpPáx¶ăvFAČľ\ď  boë€$řGa¸‡ŮţŁ0‡ç|VŔý9ßFŚţ+“qÓúĎnUő¶‹˛ő»ź6Ż¸ÝĽŤ<ż1ó"ňXâw#ŃoĐČ”=>37íž±Ě,™™.vďběťµďfÇŮ.}7»á!9°NµÖ/fŐ_ ˇ>M’ŻÎޱŔZR4I«láť™5fűĎ •[ËBru˝¬Îź?ź–gCU€JďĚS5@YüIT”łçPiťQěŞjë뮏÷ Đź ŐúYź03˘hްgćmóŰ4»:÷%U]ŞĂAnÚwŘ\+~ endstream endobj 190 0 obj << /Length 3188 /Filter /FlateDecode >> stream xÚí[Ýsă¶żż‚Ó>Dž;Ář‡Î¤M.MÚIâ¶ÓI2Z˘mö(QéSÜéßĹIĐ”hŮň9wÓß‘^ŘĹbÝßbŤ“ë'_żÂţIŕśD¤EšČ”!ĆD˛X˝úwŤľNlËW±T‹d—2ü|×űß4D0 ü[Ý{ĺ1©„HĘä•Ŕ iÂÝC5íp3ÚĆűGňjÝ#ĘS¬˘&ž~|!ąăÄľ(}ĄJ¸©źšÍ•żUaO‹ĐĐhńTn´}zć?ôxöu4o˝×đt ‚ĹPč v¨6ÖBü˛›ý÷Ĺ*XRdĚŚI˛jLůľ3Îąŕ†<—©F’Xëüăū󷄒$E©¤2ą¸J\#E9R<ąX&?Î~6'XŕŮŹäçłą bF1ĹsĚç]ú9eźcŚ—J§Ż1†ßĎ~ľř¶'$aFĄ©Ž9!# yţV«ž8™‚RP¶!«Ń:[WM±ĘŁ‘Ax¬űÂ+ŽĂ'Űë'Ú5G ”€¤U&uDÚ˙nĎÄ~™ýSsł˙ŰĹź~ á8Ďiz=†ź{©ÝŚĺ©”îź_]t§“]ÚŢň×ŮáÜâsě@Ň1}J„Ą:ŢJ>Ź6R9KZ#®NçÝUЏLaŕČŹŹSÇĽ{ŰrżwĎžă^”bAc'7NíůĂ› RNŹđń'ĺ˙›qóĂç<ęĐí 8žUw:GîÖ{!Z§˙=®Ű—ű'ű nVL»YëSáçcŹhÎ1?˙żVź9Nü­Ĺ†ÇD„ÝÉđ¤€ćr»^ŕ”ěĤ6Ó°˙ôý×Oě}/í|łŹAY˘‘J•]uďľ%`ÎęŇKńţŚâYV˘ˇÍÄ1‚1Ç-…H7ÎĘ„*&vb\ÎŞŰfsŰw5»Ş¶«¬qô«ŁÄ–&@Rc"Ô —•Ł!K'e ĄâľŐĺżňES;ćEíşĚę|éĺ\‡Q‡ëűâ„­u@&Ť8q×Ě ’dŞ%@ú(pčśó1Ä*XT«MŐiáĘ=/«ćĆ}?(a° AaĂčiĹŘ­3 ćKâľu“mŠMËYî^D+˝!ş]ĚvyYúöµűŇě*G¸¬Ş2ĎÖ|“ů‹ő˛Xř ~» ßóĐív˝Ě¶Eî;VWŽŢ6(ÖMľ5 ŕŮzrµq@ÎLłEiôj7‘™8ťŇD©‚c¤q»] ËO·ăčO¸14 łđäË;×tłÍ„˙Z¬ŻŁAô ą‰?í łĆć­:ţEĎ7x0ŃzH#Ă™0®?“Ió8ĽŘW §Đčď> úpf÷Áq˛ľŢ'+y¸°Đć1c{KwHu·vß[ő<¬ś11kCMG5Ňuľ¨B8Ľ—›HK;Ž› "~yY;–Ă8•SU*\ÓMµµ‹ďn)®üĹÉh$J$:ť‡@%çHZ:™ş˛ )śöŠź.’$T"Ĺ»+rŽSÇ"ɶĺQ‘¤é yJí!?-–| ŻÓD“O‘ŕSŠ'a7ěŕ‡âI@śözą­ôOŢ˝‹ŇßôČ%¤[Olx©męůD±ž|1í!ň’úCäąî!>¬){Y-BśţIhŃ•Ô<§.ĺtŮ}: łyi ×ę>Ős<?Äę…€{!•bKŐĹ €ÜŐrňb ‡K~¤˛¨EX6öËĄAÂňď‡ďĆ4Ŕ6ÚI·/#d˘€jjÄÝ źŤÍĘÚgi[`eS¸töŤ.Ü@tGýXľ IŢM¶mjßőm±­}očż™{¬Şu¸‡đ9| 8Ř ` ’:a—™ąîĐĚ21¸OóŮî¦XÜ8Ş•H.łl%Ş˝"ęAÔJ´@Š‘ÝC`k§\‚Eý7.ą2ř[(ÂÉȢÄ=Ç÷í… ¬SŃ'óř珻ÄčĎŠÉÔ–ŽEŚíâŞŮ7k?Ł5Řň7«»<ŰÖ~aěúÖţĂ.ĎßůŐq@Ő ¤pÓÖ:lśÂyꍵŢä‹Â\fë뮲ĽQŐĹő:|4v×ůÖ}w6Q¬Żß¸ŹŰÜ Öďóň®˝;‰/ĹĘĽ™ş‰¬FBN®ËÝă/—:ŔH+3~3eB‚±#E]=úÎŽô,Â×#$U°ň€Ĺ&i«łÝÓEŐ łË.Şq%ěŘő_>}ý9(ĄÝŃ»\±"ůŃśNT‘ühţźR^Ź@!ɡ´@ DIśę‚ţ˝ŔU*”¦âńŔőŽ¬ČŽ,ĎĂ˝Ü3äVĽČ•­t,Ĺódž_Ąsz÷ś ”{ďců wüXµ÷ŇvűJĽo†űŇ'Ýţ~‰ěÉěu/×Ňůă6ŐB`1ŕ@ď%[¦bţÔIâYľ8#xvłv·¸”}™7YQÖ“ů—~­%. z’úÚ»/J?Ö:ßůśĹÝ&÷IŤÍ¶z_,ŰbËu(‹ IŹM¶x—]ç]až Šn‹˛UţŔ}ž¤Ěę:ä< Ľ… ¬{ĺ™îů}(ß,V…Ł‚‚`Śfô D“ľď6·%©Ź5ľÜt˘\W1‹VŽ©ażŁő{¶—{2)DŘňÄ~— h‰‘Ó¸]3"ěaaŠ_·€ÚË;»Ů-=”rĂëáRnް ĆbÁŞŰËr˛Žs$8‰:ľ/2ÇÓBűbÖěPQ·€X0Ö¤OPH>UÓŤ5lő˝ÚV«Nןă~˙¶:óX©—E3ÍTqđń¬Ű]`řî¶EÓ[´«pňTâÔáNńöWs„ÇpPŔn•¤´ß ÍoĘzqSţÄ8żÎËÁů>§„DăŁmUч0@ Nňđ÷ž‡   †ď‹x¨ż_ÄLč4ę:±mĚß.¤ŚG]ö§uűĽL‚eČËP /ż9(ś¦Sç`«Iú _ćżNAaa¦Ę˘ž­Ž]fäČLň­v‚8ĐÄş©¶îL%,‘Pí`Ł >´t>˙ŹÇő‘ ЉDDZ¸ŕ1iÓ¦V¨Ż–ËĽĽ4ŕrkňzĺZĺű36ŻSÝ$f…ĹÔfËiyż Ĺöů»I26ć/ atöß "Ö“DÚÄ ďţ­e[žÁđ>ÉH‰çět8Îí_GřFY€âUK©!2ţş˙Čë endstream endobj 209 0 obj << /Length 3334 /Filter /FlateDecode >> stream xÚĺ[msŰ6ţî_ÁÉŚ§ÔÄ‚ AßőCę&˝öÚ^c;Ó뵝”˘  EŞ$;˝»˙~»řjI–}NÓ¦™$A`±xv±»X@ÔyĺPçłşĺůÉĹÁń3Ć='$ =çbápJI@#'ä!ˇs.ćÎ÷îĹDR7žMu35™ňPşŚL¦žď»§Ĺr—iU䦾Xg\‘<΋:]BčwdŞgqe śŮvůÜqUëÖ?^|Ń2řôâŕ—Eę0`M’0ťyDxÜI–ß˙Hť9|ü¡ď¤sĄ›.I‰Ę™s~𼙨t"˘0Ôe> }ß ©O$f˘µŞj`—y‚ąĄZei×i‘WP'wUŻ*5·o%ĽÖé› ®áz3·(•Ĺm1â–۸š0áöpŽ$ÉPř"‹”xÔ‡˛€zNd$Og‘(đ6Ryy•Ö—/ŹşE‰]Ýe řTFcŇahI<"Ú'Íw®ťLćÓ1µ¨ŁJ¶ťŃoţqţů?Ą2Pa$$|”ÂÂMdôÔ@ŮZ:‘äŢF…e†¬ß*ÝŔ€Ű;Iw´ř|'""đ9J™čgń|Ď (,C„s ś'EţF•UŞ×®H˝v ÄY˛Î´Şę) TúĂ•Ę2SzĄrUĆöĹh 6,VPkUż€Nż5ĄfúR+7°ęÓ« ž/`#FOO/ţe;m›ź2†Ł~Y:+ăŇ2đxÔ 4IرězŻgź@·o/ÓÚΧ…ä«4ËT90&Đňh/‚š§śŽ»KĚOóZ•‹8Qs3îěí.¬0E$@ł3׳dµÚ'ć –Ă°ďţĐ<ťĎU6[«şVŮ}Á·N ôÝĎ-iţ ŕ"·.&şźµîÔ]”ĹŇ”Ní„=±E1Đ^r>śđăÇ·©,w.İWZ™!çE®Li]ĂŰőZ‚O ĹM™ÝÂĎ8ČkŘm'ŻăW–…{Ęnçł2Îđü°€)ŢGŞ=Ť8Ié&á–SĆĆD˙˛ŻŞD74°Ľ‡•äćµ@Ť1VőD÷Š32sŚ0§„ł¨éu´?;Ű5× ‘Ö ť<đŔŰü H˙–˝L|Ć("nŹĂL}¦G|¬CDľA§kpÂŃm/ă¤RŰgÓ1« [ł\ej©Ŕh͇&̦™©őám®ĐŔÁmxIŔ†.z!ĆfDřČ;p%˘€x·ÖÓ ŘmV‹yő ·ĐęEÖ;Ř`ˇćaßÖt!ű›®ĺ,ÎŐë{zś(Xˇ`łűENÔu˘˛Ę”1:Ĺ&:޵Çzmôń˛­-§©ĹÇ~o2Đ€Őş¶`ăú©7™®ľĚ8,Đż ôm˛öŃŇFĂ~č-őLt´Úo ±•Ť!ř—~çú_\ś‚†zî'cç@ą;Źke";|+f?«¤ýőuźşJk>–=w¦ňär—ŻÍ§zđÎ0Ćv 2Ř˝.á{Ő48˘¦ ×ńdešW—Ĺ•mQ_ĆuSÚ˝|„}J8g»©ŮŚ'‡V°Ąmś ¬®“Zo`0Z«Ś—Y®“K1gEĄěW¬DšK]1ń˘1˘&^t±°nZ¬€·8Ű5)źŽ8»Ý(´O6E űĂV»cű2Î-ăEź=(,‹Ň2Ú„ý;ŤW¨Ăv›sĐ)FL¶Ę°·±ŰQ«BŔcĚlř#·R–“‹Işń,Sűűîq˘+Z¨P«:NłęëČ©őŕ˝óőVŁÎ•ĽÝéş§°˝ďoä¦ď·鹪ĄJĘt¦:ťŢŕ/ 4XNíZkľŻ•öěE˛‘{u™ęĺ„ëa±€Ť© ĺĚ#).U >¶Qşii{»RMŐFĂÍ(Ö–>rX)P0ŰrUŞ$ĹŤ01|A@dÔ¦Ć!÷=źLi- >ľĆGrm ĚžÍŘ'SÚíUÁhSŔ|@sh}~l$d ;w8Âč˝řĆň˘ť­Óln¶+¸ÁĚŠäuÓ¤°uŘÂ4¶+^2ĂčĽUł5µ[bfö¬ŞŞ[šMQÇ34©>G$íVĘš0@uŠą†˛Q󭵎 §Z]wßd|Ň@ňFŻŔuŤn¬ĂNáĂV¬m‹ OÁ ¦Şúń‘$ńOV+•ĎÓëťË#ÂŔÝ AĺYŘEî Ü ďßą.~ťŐ•ů†k 7E-<ř^ßÁ4cÖí†i†ĘŘč  Čç†~aDZj-tTÝ ťdëyÓp¦2X€“öH-oHĚŔĐ禝pߤ±©V×*Y7)ŻŔ]çsăÍľjš\Ů@·‘i@LOx“uň l.Ť˛–ë<·‚¨ĄĹłu^Ż'vGItNu` ľLóőµ)ľVen6ě‘+źz‘] ycđĚÓ&¶aNeHéßÍŰé7’q.|´B™çI‰0ůř‹í>stc-ApäWVĂßç˝˙±!ˇ¨¬ÎňF‘Ă’Ź<ě}ć€'’.o«ĆPqąą)üÖ9Č{<Ę~ŕ7ĎeW…Ýé{Q3h;8Ć-ŐM/3xŞs6ŻŢŮX =‘ϤĐáÇĚ/óúwÄÁyoŕŢh]ťŐ–^±yšm›ŕ΂p‰ęìŕż~9Y:#ŐÚv˘D´ĺă`'đŚÝÔ€éhFž I¤‡Á#l—ĄĐú«“á2ěyŰČÄcöŞÉŹěăŔłŔ8`m~ ·KŤ§Ö;%cángvÄÍÔ’Ľ÷c§l-ó&?аÓŃöŔZ6ĆĽ~ą*Şô:Ń»äP¸ť6Ţ‚ˇ«Óú­ĂčלÝMIFÓŚ"KĐh3`›r(Ęë—ݱžÇ` ˙'ÂŹÜôöŇJß/ţúŔ’‰?—Ęw"0őO–p'ńń×ęęĺwEůú=‹$IP(H攉ÇT\Ľżeq/źÔŠ Ť§ÝmDva懄†ţý0›ň€`¦v -ŹşÖ(=÷Źď¬7¶ăżŤT®Kýk€ĄÍM~vn+¦‚ăőŹ>¦­7YcśŔŹî4 BÜÝŽîe5?¨ń¨1jˇel·cą‡Ĺ: !Ţ ŐŤüŕ°îß»+Ö ˙€mhš ?–ę_?řNX—~ř!Xş§8‹ě+¬‚Ű%`Îé>)Hđě÷ŔR8Úۉ۩8?ŚąoÄr¸śΧ‡ß]ţíäđ«“çŃůáÓ ÄÝ {°7ĺ>Ĺ{õ9ĽťŮzËú]˘ ›qФăc°l˝ÜĆÔťµCűđV9’Ý*A¸w˙°ďľn )÷!ˇ'ü¨/ gŻÜ>cúş®Ú¨–]Ř»!Űj2Q˝lŐó.Ť6Őy´i“H{îôÓmćoîô«˙§]žÎ¤™§˝©ńůÓďO_57řż˛WňĎńĐď@™«ěqŰ«üOö9O$ĺř(o˘eęÄüJŕéu­r{qą÷#źtăE‰Ş/ŐO›äÂ'‚ó‘`ěŻVq‚ă4gŇŇ5·ńËn(F ż´S}â<={ň593ň[•…ľsRíqöń’‡0‡;ěľ|ÍÍK¤»3*ÝOűRätűRá$ŠZýon'źŢáűG¦üIšĎÍ5 ýłŤö‡đbO€ˇ=öµíżLgFŔ%^rßn2ŘđĆęŰ[Čŕ@Iř~eÜżÎýŇĺŕ!?¦Ř&ްýqÍł‰/\u{;¸˙[»’Yss ţsY·ëô\ĹËLUŐćźčś>~l xpů Ç1Żź07'đB‘˘żIż¸Ďť-nLzś ŤÂy «bűáĽXÔWhşđ|yňD ü.7rÔ4ńúĆťDÝ™‡O7QýúÁ“D,˛ f0ůnĽBß)T0ů ć«őëŤOŹS*˙/—`Ŕü8p}n„ ]bŕN–†fľ˛C¤kĘô9rÉbĘŚyĽ]V‰UURÂŇ2÷`6.­ávh?ü€OІůńÚi\_š[RŐÖ ŽcŔ˙‡© endstream endobj 228 0 obj << /Length 1650 /Filter /FlateDecode >> stream xÚĹXŰnŰ8}ĎWŘ ­iŢD‰úĐ\Űô¶ë¸íCłd™±•Č’aÉM[ěÇďđ"[ňÚín×E ˘Ij†A+]×:ú,ŠĐiôصϢe@ JŠ´Ě*×;´Ł=Ëó$[j×yđők滋6fż¸y/}÷Ë@T®ÜŹ?Ľ‘᪪tî}żń3Ź“ZWnü4 ůą'łd>ÖËŞńh;ŻIHüÁ“âŕĎŃĺŕş÷ ŔC‚C.:0 ÓĹâIĐ炣+ťĚŠr]5[uʤřŐb¶E5.ąr.G3XĚĐŰ….\ ¶Z¸¦ĎD˛ÉDJŘLôí—Ž“Ę_-tš]ÂR{3¨\Zů ‘ GC;ž4ď‰ÎTľ®„‰SémÚÂÓ›şĘŠÔ›ŞÝš8:[@uP¦3“ăčŢ×ĆEp†%°Ż :†L±áÓřę…Dĺ÷_O\Ň)Hlźďaó& á]o\~bn3Śł ăÇ'±Ĺj\ŮŠŞ„şű› 7=@Ú˛€Ł¬Í¤’J)Ş"Ąźýođ^Ü|OnŇY˛ ÂÖMżŐÉô†ŃĐ‹ŐOşřĽ[Ž“BßűśŐ©–ä^u“ ,jRŹMkIU·î3çAh»|v©ł<«}uľ*ŇÍí¦“7Wťß]%^9ůk—g'đfS‡z1Ú••ŔPü˙hr4—aökScÔeH±%[4Ä4ôJůa–Ő^é7w"…^gy®}|.ţCňk\QNí™ěřň;Ęł±;ŕűĎ:ŞM …ŕ¶M©ąŻĺ hŽ Ťý]Ekź‹’±˝5ű $MOłOYîílęúUµ6ä4.K¬ň&µşjĚĄX˙¶k}5§Ľ,¬®âËr’ôG>D»n0 7–],-Őˇs'†!Ů †ŐŘś#{É›–ĺ4×4­żţŻ’ÚmRÂ&"eOZ—R\bŢ(ăö7•ýRL$Ćńć&łţŕŠĺlZ0źr†ţÚ\s6+‘€ěć†eÝć&V^wXSëęnµy_…k;]Ä8ŚÖźpT—łŃŃßÔ˝ endstream endobj 247 0 obj << /Length1 1456 /Length2 6754 /Length3 0 /Length 7738 /Filter /FlateDecode >> stream xÚťtuXTÓ> ŤұŔŇËŇÝ) )-,° KěKw+ÝÝ’JHŁŇeŇ%]ŇüVżOüžďóľ˙Ľ×ąÎąÎůĚĚ}ĎĚ=sX™µőxälVPe$ĹĂĎ "deUp…BPp$B‚‚Šô (€Ň ĹŔâ`0€_L 퇣ÜPh_'€ľ·3ŔřŤĐvEÚşBśĐv¤ł·+ÜÖő'q@w„ł»•#ÜÍjđDş:¬Ľ˙? 5„5/7@âdĺ ·±…r4ĺxŃHrŽŽ€?HnW¨ÔŐjĂű‡Ű@(8ÄŤmpvE:»Âˇ(«7…ü.:Ŕ€WŹ ňä©’®–¦’–>@WIO_WMA_I «¦˘ŞŻ‡öŃ·»Ü0”'Ä @ˇ+A¬ˇżˇmÜ­Q´ýę¦EçGŮý7/ŔŔ ĘŤF˛qwv„[˙i%é °»Y;"ÝÜѨčšQvP€ ŇęŠpBđÖÍÝĘŠf@'Ž.ĺ ·ţé†BwÎ ŠŔ®h>8âO,Šp ¶®Pčß @•ĺtB`^0X„‡_ ´ćÁč[âÍŤÖAT„ăwjžvPâü'?+GtźŃůýFý÷Ń_Uşý΀„ý1*>QüîćŽöúÉF˙KÄ/đ»ř_Q ÍĘ/„~ȡ5qüC.Ęń›čż˝D8ĐH˙áÇű[\”+Ä…tĺs‚ ÜŃ" Đ­sýÝ©żÍËď,ř…ĘpW7@m€˘ţ6C_Ěű3‹Ć m wCA]Ńb˘Él NôD˘ËýŰäđóŁŐCKc…vGňýžs5 űë-ô?MhA˙Ş Ě ú˝Nh áč °Âů´(´pŕ˙q7ţÇMřŹ=ŕý;ٞ»ŁŁÄ Íůo(;+şj€<ŇŃćżü!NpGď˙%âďΆĐ?5˙' 5=Kr[ô0ţ:‚»)Ă˝ 6Úp”µqDĎďźs„ ÔŐŽ€j#Ýŕö…‡$ö7z1­P77€Ř_pPôŔ˙-w´02çSÓP|ޤÁőŹ´ĺőy~gř—“6Ž@ýůcţőŹ?Řżľ5!čô‚xA ~´#úúç›ůßH•ÖH8Â=z脸Úüëŕ_hňňH/€/ż°0€, ŕ bÂţ˙ eíîęŠVńĎLˇ‹űç7 Žî ęµ&śžDZsŞ’]Vż8+‰z0şÖÝöZi‡Ţy,M;;·ŔWܨľqTÖl90ˇ20BS#cgň\Ěł6·Ô4q°E&„ą†˘Uů@äćśÂ¬ŕĽHŁL%šz6Żô‹Ź¸µ‰j­L9ľ~J8ć9ÚÝł,˛ŚkMžŽĐQfîńd­°X2¬Ďyü,Ń•R§‹áéčhŘřE>×RĹe ddšżptŻţžCŞ˛~6Š>1ş×<¦˝¤›/¨TR˙~öŁ™&>‚¬ÄŚŮH¶«‰×¸u^67 3ö-˘\[ŻzZC7!7M[—€Ľ„Ď7ődĄRź ŃsĎv ÓtÓľńŹďg}üÍĺ”ÁJ L¬+ď—]‚©ö2jŁYîŚNš÷Ýäu¦Ťń:Ś˘Ź® Ş•yąśIK¬Ú“5Ť 2ż†Ä¨ŃÇrŤß;TڔЫ‰Č’؇(CzîĹ?Ańn¬¤UdPíá |¦G”ę ňI´’ĄCr++>žś{éĽĚ#HĄ+`ÄFeM©ćÇäô§Pň}ě=–?—2‡ß®«-’:Ë(ů:¤ž‚ň¤Ś‚ý b™ť×ąsŇéőB7`¶"ežŢZ:ÇKXpm?|O´ÎgÉĚĚnĘŠC,äoWäň@NIîîôéĐëÓő’Em`Ć[Ľ~üѶŚ)űŞűŁŽç7‰=Kď,ćt+x>)„ó7^ Ě\|âh–kă(‹†}*¬˙ĆíhîN·Ĺ1Š/U b^=,ˇ)‹BúżH4P ,ELÉ_¤Âç>©¤¸…ń˝VHk?äâxĆÎťAĽ‹űéËŠ˛¦ßŤ^%ç']Íd¶éa\I^”üw71Gv¦Žăp‡^µŻ3‡˘–ßv RűµX<ŻÇ0´ĺ=ŇĹ|ú®sąIż&µíťŢyŤ«=ĎşôÓ źđšI°ăłÇ¬Iü÷ęh¶şÄő32¦Řá—"~×ËÁźÓ§A.&9CW'Š”›x®UÉŇ%ą–  .Áźń dP:xÉ/gÔiđ1GAůŁĘ¤MLřÚűb­É1Ź t\Wé¤ĺ?¬&ß8C ›ů“Őó0žg«čW™p­¨Îß)çĂe4Ç7râ\zÝůśÝ74™#噬&ăpCă1áĚ}mŘwîAČ^›Íś@Ł(7eHő]¬c¦¤¶9 ěYHθČěŢŮaUđűŢüRőŘŞ}Gś¬Âţ,ö ¦ÇéMŘ#ĽÝ#ĺ~ÄwZŃNbŤŐ)ő]©Şă»ŘoޱXŰč¶r:ĹŐÓ73wźĺwźa˘Řu!ϡu“x^Ôy:ćţŠřҢiGśł÷ß/=“˝>®, ŻĐ¶ß—#­ đá Đôí2hliŻděXR8źźQtČP… óŹŇseí„ I|W¶nőSĹOrꏤ§ż˘]mÝ,•‹] ›ŻDňGŻ…)5rľŹŇĆâŽXŐ’Éx¬p@Y»t¦ł.şŞ8ˇ\`Ç᫚˙Ý-Ąň=QýŹ™е—4;CçÜ‹FÚ$ᚥ{.ý1ěv:Žřˇî8F?ĎŻOJJwśWG'©ł9'4e˛’ćÎĂLR`1"¤¦¬R3?Wď@˛ľ[Z‰ĺ­†}Ë*:_?Ş´É˙\đ.źfóC2ĚŕÓO ±ł'íµýů2G•ŮŚ·ş比ĽrLQk2 ÓźăQŐS= ĺçQzŮîAĂ-ÎѰŢĆżył–ę’5Ĺx¶»^ $¸ ô©Ů”TÔAňŕ,”#wÓ8ËnŚ[Ś9G,ńRI­&ŘëÝďz9Ňá]Q’*[Aˇ&î‘‹Ô‘˘÷ňM ]Ôű…X÷}6y }âo4ßżž¦PLßpîrŇľ?Él¨ŢĄúÚň$ş®ˇńc0qqýÉú·Apëů› ’É#F…śŤĘ‰î%ńQ¤·cűDG|;ěĺ«TµOŐ‘…ÎÚĎ;ĄSÜΛů~ÜNv¤Y⧸»óÂĚ] vč¬0~•üHŠúHm¶úJňPÚÇ?*łŔţsdáů•»ŞäĂîşjlçlŕr\Şo‰<é+¦Řó… ýÖ›Ŕ¶`ĺȇľ…™·1aţ5J5˝â_9W|bUrp†łż‡´°Ě‰cçźoa>d`ŹĘČMĐ'–ëŰÖµő6Őä`ł'ătžź2N¤#ÄÇöîúĽó} ÖO×DnđóaR˝äDŐźiŰ3łFp»0°ĹëŁH0ńLÓŞ‡¤ĹÄ룙ĘsřŮ’»żËŤZ$vµŠ¦ô¶ľ«tű˘<Č"Ö%öا@(™FŔă5,ŔĹ0^’]ŐůV{Cľ‚h¶MłYĺHä'¦EÉúk-.†ĎT|‡“~éŃâžą…{¨§Ű¦ f?J ¶ÎńŹ˝ôŁáWüiÄŽKRÁo×óëž±qď:ÝĺlCďQ˙Ŕ)±Ö2±>z`îĎŁOCÄ,â^FNŞRĄŮ„޸ú›/#­±­Ó#e†Iś˝ď3|5ż×PcqÄűďÝ^x4É^áÁ|%wĎrŰŢó˛v¬oŻČýx8A9wŃ ÇFÔÖôpŕż°qqtȉ./}ČĎ«kÚŽ´ŹľÍÓńjEIÎŹâ4›úČÉŠÁ’n †ýUn« ©MF~[W÷ä¶%nĘdMóŇO|üHöľ‚E~.zfŠŢľŞ¦ˇž”JŠí«Rp_o•¤Ž#éިÁĆ•ş Dq]Tw$RhâšS żwe¨pÚ L†éhVGwŔćšÓbsµ¸ µÓŁceY‘–'¤V‚róń¤ýďĚŞYSĆńZĽ]%ęĎl-ž ŘŇŹĐČĹ1¤Vlś¬jqwR‘<-ňuÎ,Ťi‰>4¨Č“^€5AwtĹóÁ5®Ĺ<"݆źáŻnWł UŤZď±RX&Jßî©Ô“EžŤŃöTR•WsĘ^ĺRöšZÁđ÷ÂßÉPf7r”çv‰0áĎű°ŽY‡śśŽ—\QÍŞřŔ¶CĘŤ3« ·VýŘëĆ ˝wd”IĄ÷ž= ÓgŁ Ţ1 jj:y7ý~Ś<'JVĄŽn°ő÷óSľŚĆÚRˇô/í=­Em%ś_‘‘/L®şDK6&˝§“ńesëĆŚŠŽÂË­Ş:n•JzŐüăÖ©ăWZś:¶z3„2•«mCQFę‰Řqő'/SîT»UçňMcG7“#KÔÍţĂ(ă˝ř’šú„-Úýň]ŹoŮ›‡ i–“EäŻĎ¨ZbPuú€‡–:OńuŚ‚ýOżŠWWžéŠ'3O 0%_šŔ1VÚ>|K°d*^á±?đµuyŤą’X#°}|xâ„%´ŁY·aW¨f{>Ăa±M8VÓđię«o`ME’ż]ëQrtĐĄ/;Ě>ö„V‰?´,Ĺ\Q¶1–Ş7ĐŘ=ý…Ł“m2sá(•ůxgnšQ÷vN.ĐąO •Z‹˛{¬St -*zqu?¨ökŰ÷¶ă®Ĺępc7˛LŻokěęŔ$É[‰UH\·ą€… f9ůtłD=cqÖĄÖ"$Uq$ 7P›´ŃäçeOäć[đ.0Ĺß`đüSľşcĄĂ"FHÚâ}jYăW*%]Ët™bš˘dÍô˛(kb˛LiCłĆHŔ(Ă Oʶ+ŔO÷ąV‰/éĽ)–ĚOlĄ°»R® U–D¸¬Š-Ćß"!…®–™Yc0˙íŮ)¶¤=f̨˘ËżD2€8fÜm{ęśµn;ž]śűXZŃşD˝—śúÉ'u'šÇ6ůHŽZśĹvu6wÁ÷Zľć6mO-Ă˙Řfř’¨obĎĚńÍöŁcşY,nąt Šnł –áćxcéłV¶Ć–wĎ„ŁĆ„g˘H~ťÍńłt#ä,¨ ¤[4¨4¬EYި~~GoÓ?M4+î‡ )°r UÂlíâŁő; >9|+<‘ŇGÄ­á4s–IJ ­Uq‡wÁ7©ËěÍŁć[O-şµáĚ÷XJ›ö.(N`Dĺ`M¨/"¦#&¨}Äř±0ţ– cîŮ-mR~’Tý¨álüłj Ölĺ+ńřĆ`.ţŘKŔ›éľ‹…mçöq¦y·ąrbY± 5óÇ’ŘFOšbą›‡Në¤Ű‚üď+Ź~{SĂ·Ď?łÁtŢURSz­Îś)_šÚçąÚóI¶uŞ›˙hńžBqĹ©AÍłV§cĺt ŰĽUÎ_ÉĹÉ~WyY#,QY—Nň’¸|×µĂy#ŕkťý+fĎo •ĹxÇ˝“'†—ÎA<úţ­ëÖČ2čî3ü˛’žÉůS_•Żź($–ábź¤O(ţ<ł—ňí###UË”­ôÄ?a¦ń)p&6>Mż¬dóîú!¬źA˙ę"ÇO~ą¶î¸švc"ËÄŞ«±ÉË™Ú_ ę˛ËšeKJŻ=ó÷r¬;7~0÷M˝GńćĂ#Âľ _—Çé<ĂßĆúř) j™í'ŤIEµ®ěúdŐ üÉÎ5őyh t±!ţ,g©ÚE‘>ďB’Í$ó6ß ŻÝWÍ~2“qK$µe\ąĐŃ«VgFő[ŇlŔ0ź7ő,‰‹yWKásŔî)ăkz'ŠçŚ=4IÎľÜÓbzh@ŚşÇŢ÷v~źźGř5ňËdŁDĐÇdéëGб ě¦Vśgon¸úólq¦Hşîô» +°÷Ŕ •š‘ł°§e­#bńf¬űĎÂ…p¬™ź| sJ™¬ě»´ř‘<¸tßg #×RĚjÂŬźvŕŔz›ő(Y6"$"Ä'@ô"[©“˛Ô±vFů“X TŃůś(Ιlw6Ĺ’ÂYiMĄűŁ“WşYA±®é$l Ş˛úPXz˛ÇeŰ_˙勇$}ďŮ÷‡Ý“ÍÔHf]{˛ĐRĘ)CâBrÎá«9˙ ‘EĆA]źé)é.AűřĽvעâ«llČŕśjG(uĺ®gşáSęý°`ŤĘ™˛8 Öw´äÁßFßâ–`KD•*ë/©ÖµúŚľĽŞ˝ô9ć7 ÖS =ÔďĘý 1ŻŞ,Rúš‚»}™ëVÓľ1Ľ¦„“oĚOľ\o¸Ića_ođ/–ۡ¸ű«t±śĚ^&¸‘"ÍKş{!ÔC UóxlÖ(6ŢqĐs±q†±˘Ú,ćrŠĹ s^Ëd4°˙ô˘ƕ䇣[yGű*«*˙ŃÖA"—/P{ĺˇ* '"*ËůJů%ě«yPqHŚŇµä#_»Ö,ýĺüĎÖ7ąÖ{ÎçÁ_É Î%Ęl ýc#“#|7—Pî9…¶Čq¨c‚FÉíGwFśDV—ĺ-Ĺ@y*ëäâ´’…~łÚôôxąG}Ş#Ż‘‘ŐŃÇ‹:.÷i#ü µużţ[Î qRÂýgz\ź›’Ĺ'¦uUŹ Ď–™Ä$:eŇb핵GaŮÚ¬xgţ| G©Gż\3‘]žĆŢ«™=ĄO‚KěÓĄ_ó›ľOsĘeĚđ Ô0j~?ś_]vśîĽ\s?äjęLPŔš2:x˛¸j­šď8č[ŰsŇrˇ©Ł%5 b+|pççGĐŕýw۬„´‡Ś3ÝdłâĹ€ż~ö<AŤ¦rĚ[¤›/RňĐ1ཀ®áű$?]§šQ¤Í{ZôCś›÷ZiV°,‡Şh;GP¤ŽQfu—­aŁ5Ľšţéëj>‘QĺCNĄśfŁ m¬(Wl3O”!Ňű{¸ çŻ]aoe’|ŘĄ‹Ţéۤǎ”â…G𝄚°ĚÂŻZ14˘7[Ĺ Ő3Đ<“ŕĆeß×çAÔéćYuě{šuI.éů¦~QçÓóQÖWö”âYZ!ëďŮĚĺ(KĘX˝çýYq»+ŰgqßąHX*K…:Ćýäś[ŐÍŹ‹nJ=ĄńŤS°Ük#‡ßMBË\lL3č+í9ĄV•ŇĂ:‰\”hp® p׫1`6ą„0ŚĄ1cXB=ůkU÷‡­'‘Übţ -…Sş]>]`¨$§›AÇ †”q:‹;>ý :ő+źĚµSs† n¤ZŻ«ń_š‘>}´ďz\-“x˘˘gľ§Ť=”ĹF2x0Ü ÷¨Ä5¦=mÝ’°Skkóů`,áZ´ůÁ>çöÉ 0®őɦĘÜ‚˝ĐćL)ćkúěU}ÁĹR-}÷Â:ţé#[6=ľâ3UH˛YňţţlÔťzü˝ nŰĂWS" z[ž4©!Ě=VŢÂ]ľ“r^$šZtËw/~Ьë~ľÝŹ ćQ ÔĽöť2")Kň~KŤéŽuú†MivM÷îmĘwÎ1_ĽÜ3ýÁw©5ř|jÁM¶ZK_M4,/úKąE%)©ĎŘ \^zĄ]\ă” Â Rň‡M8‰-Xôú•«lÜ»ŽoüršK_f¸úO|ĹŢ€”ë×|R«Xž{a¤1V"^¨ŕj“ć´5K î¨=«f⬵8-@Pűéđâ„Üö$¦ŤYŽ×=z0_Ś;6V˝µś§lj"TxVšź%±ô^4†µilă­}ă;­;9ĂŞo‡ČWvyŘz4Źćź¨RaĚŐ@§$/+~áMv.Ć”CČóä(}&ş{'NoRhاżÄߥŔ~ľĐi¸eĹ[Ă€­»x?L“Ă Ů<ߤy¤ŮĆT#¶z.ÉĽw¶ßq^U?7š¬jîN•ÂŰúE?˝.MUĹ,ů(Jăá;$·C‚, QôU! ÷ŽN3aRÇZ/XÁŘ10'8ĹnÝ ę“đ7ś2 9ĐR$mO,öwŤq±­jţnIs~ź‘k¨xrčÎ ^ô'ż`­ÂfÓ»`™ŹLîs 6¦˝ýßÓ&xÚ3łéÍős·n{5m2<lüŽÝF«3ćnŐŠŮKz{Ú Rďł=ŘÁĹ|_Jٶś5dSŹ ®Ůeň1˝zÓţmŽą¨Ł™EWd‰Śé(˘˛4ť¸Żs9>ž•çńÚâbŻnRÓ¬¬ç€@–(Ţ’˝Đf`q…b*®€Z‡ŢĎŇZ€öďT|ţ1ˇ'dÔűkzös–âsŚf÷Ôőyçř$ńˇpJ¤âą"çÂČŚöťýđEćëȶDaE˘~ăW/7żť‡ _ŹçżQЬńď•ü9ÜĚĹ3čFudľC'kKp÷[öĄĐB·]B¬ş×iěĂňBŚČĹÖUcÓ] w_łĆ2xś< P¶x`É4Q©6ełŢgk8pa”ÔA˛ÜaÔ+alçţ9;LöaËŘÂľd¸Č=ö™´é©‚ ˇŞ';ăÄ"‘2› lÖéކ ‡y}[ďÓëYđőŤVĘ3*Ń·ŰQĽŞ»’~„U^×/ľ’wň`O´H·˛@{”“ ě¸iÁćmlOń6KřĄ Ü Żyíř‹~­'“ěĽdzë3Ąů˛\ óyĚŘÂÝĐĆ)8ď¦XÎÓuŮrD©Lg/Q}Ęř⪖%RŘß1Ą˝†1†¸=?z7mAŰܢď•W+ŮZ !>$”GFĺőŮMNÉěÁíÁYčÁX‹’cM™\{©”ŞÝŐ•ú„3$>;î¸HÎJ×398Ó¶şňä4ĹLx¬{¨˙Ś«Ćł5°îáć*Fą÷•ęO©×ąâĎ´7 =cŘt°"Üg™nób]ěßŢş[ä‹ü (MĽÍ˝ń8¶Ż~±a.î«jŚč;]ĹŰÜK•,÷üRެ¯˘Ňűq©îFÇšŮPŁd@śüÉF–7j˛lkżĺ(a-Üş9s´ă-.75ë­11ĄćP{)O6”Ţf٢:§ ş"±ň˘ÝHń1J—č57ínKŢí‹Čâ5µ˝9»ž-–;ÝTĎżŽ˙aŔfgń*DáAžů˝ŽÍCĄŘCŢô‰¬rlk—W2züöđř÷ôÍ{€Ľü,ăň8ů…¨¨ękDsŹîŢŞ‡g[A=+łG¨ąwʵęěy·ÂXĘgDť âŰĐĽú0Ť±žn<˝źźđ‡aú—L‚,:Ş˘:)á:°fďůž´ć‹zL=ö›Ýűo/E9÷¤Şż>MÁµ®â5âżT·ŰĽyË\_ďj°M/şČf^ňăçkš×ăÇćI¸Aďë2}^I.D2ڰr‰ĄÚ^Ž"Ŕ]“ö᛹ŐwŢD§ ČăąSÍfľÜőLĺ‘28a[HśX!˘‰8žÝh>1Ş_fX™Ěč‡1v©… âmSŐŚŇavłBFď”6Đfgě™­ÄÔ–7Ćdß|ĹJ׳wô—V)”Ą ˛÷ݧĚ@áńßfn¸Dénë…VެĽ ł›éz\äĄstkůęř{}f—€kڏ›ZĚĹż¬”lłŽ‹­I_$PU=Řş’VBpľ¬r즓©^ě,E‚çm˙1ÜqÜLbXŢçC ‹ärżYZË©QÖĚuD» ÉíĄź BĂNHŃ^GÚí·}€ů‡čąĐ+ĺ4AůÍKúnĂÂ=FđŇŤ¦ôô pv¦:ȇ3ńˇýRV”ĐWOe;ÎĂ4_]Z;Şc‰Â ŕ~üI@×ÍĺŰŤ3ßŕV\âősÍÉB=¦úqQ Fč“6AiĽ0_,ɞˉkˇFÇfČ~#ü©vŢcťăm2lXÜEĎüOEsßsë6vĎ,sÜ ‰¶©ŕ—ăfµąŠ8ďśôą>-> stream xÚś¶stdí×-š¤ătlWرm۶+¶m۶mŰN:vұ:Iwěää}żűýÎýăŽ;jTŤ˝źµÖś síÚdD Ę´‚&vF@1;[gZF:X22aG ˇł…ť­ˇ3 ćhłs09ą¸™ż.8żüBÎNÎ_ľ6{ €đ@ÁŃÎĚŃĐćË.lgďáhafîüoŔĐ `h p±µw1˛¶p2šÜě­F˙ I[c:€°ˇŤ‘Ł…‰ +H÷…$hm řÉ ŕt:şMčţ%°5µ0Ú:[Za›ěíě-€Î†Žg»˙Ŕý PĄS¦Ë«‰*ÉÉŠĘ©”D•U”$…UDEJ’â*Ę_>*ćN';Sg7CG Ŕů«2SCcŕ?Đ&.Ć΀/ăץëíWţÎć˙7@Ő Hó…dâbomaüo+vŽ 'ck;'—/ÔŻšťÍq;W Ł­ÍW˙Ŕ:ąYżľ˙*ŇŮŃÂřźH§/ ŻÎ9ť¦vŽ_|¶˙Ć~!mť€C3G đ_đeT°2Ń11±Ó2r(Ś)L__YCšŻ9p°Sţ“š›9Đ`h˙o~FÖ_}ţĘďÔ˙sô_U:ý“ŔÎô_ŁĽČżčN._^˙r~!1ýO.v†/a|•`bń_Q Ă/VFÖŻÁŻ™X˙KÎAůŃ˙íĹNů…ôßüčţ®łŁˇ±łť#˝Ťˇ­ËלżZçřO§ţC/˙dÁČ łptr(€Î˙ˇ!# ÝÓěŽáWŁÍ,śśŽ_Ăü"3Ú~)ň«Ü˙P#ă×ôľFcôĺn K˙ŹÎ%mMíś˙uü5č˙eúčŐĹDÇđĎ:Q~QšŘŮZ{L€¦°ôrvÎ_Pü˙ÜŤ˙×Mřo{@÷źŚb.ÖÖr†6_ś˙JŘÜĐń«ę˙ËŐĐĆÂÚă˙Łł:đßô)äěm ­˙Ó*élř%$A[ł/%1üב…“…;ĐDÁÂŮŘ`jhý%ŢĎUmM€ŽÖ¶@;'‹—…–‘ó?l_[ile tr°1ţk~©ý?˛˙šĘżąÓ+ ÉJ ĘS˙ĎÄ…Th•ěľ$ô_^ †¶Î˙>ŻţOŘ˙|~ýď{YĂŻősh3Đ100~9~}ţוî°ŠÚŰ™XŘš} ďk Mţ÷Á˙F˛sxŃ2~eNËÄĚ`dädp˛1űüw(cGÇŻţ«¨Żęţ×˝©ĹW @w 1ěúŠť1•ĘkmÄSI…+cĂç‘BĐ7i>ś­í]úâf©Ó۲vő°ń ńńiě:~s­¦bÚăíýÖ ›řs„`VĐcgńA8'«¤d"aű=l1LŽ”§…0˙Gz„ÎVĚă2±¸Ć5ŠE·™ˇáöHcÔ4[E1˘a7˛ ý}Ő•Ćli˝G Ĺ>|µ™™ŕĄ—<(ę}_´×Ăéu$č‚™?ŤđVˇÎŐŤ[‘x Q#şŃÝ%CôţĄ<*ČY¤­ô0™ » [aäoËU î&×Vń=–Ôç•ĂťAg†̭節|¨řąŹF”RŢôźŔ(m=âˇŰ)ě!śꏱ~ă»U‡|W ĹDBCůŔľ©xŔś»FöAoTâŽ×ť=Nč´űM$^T=ŃA‚LĐpćş-śî»a´$^ őüŤČDočv]h¦ ˇe ‚á0|śĽ3ÝéajE:ć[ĎőiŃĆ|bzîNTŤ4ĂżęŠŮűgwŢ\Ü|‚ ŠPŤĚ5‰Ľč\€Š?Áú/ĚkúŮ‘;ˇgî5]‹ĎÉ=${~Q/kdކ\^ŤoŐ"űšě4<ĺ SS3ö2íH=®µŻ»i@}:äŹĂ ˝‰ż74 Xî„űgŃü·Ľż úy‘Ćt˛ ‚/âMúRÇ…”ëw†•4ş q[l+4aËČ-3AĹń7ĹUpaBőŤý«”ë†8ô@ę5Ş׳d#pc°j É‘šç%ăˇ[5{ă”ěšY‡âRť®’±đq)ŤgÉEúáÔ¸”›ÍvÓłť»wů}“b„ŹĆÔ°Šx|^‹?Ąř¬Ä~˝‹ÎőYűPÜXÂűb3?Î#L€ĄňuŮNýÝ.–Y N6_BB2}%{}«Öę%_¨×…†W€Üʲš÷Ĺ}g—((FY‰?˝ í´{vţŃ'ЉnÎĺiśJAéAŢÁčhđŞ‚Av„.Ůŕ˙‹ŤŰ7FRř“•Q3 ×-fnr›¨«ÝaŞË¦€ ·[0µÉ݆žÁ‰ŇŢŔ[.+mŹD ~3Â4ÇŘ(Š|×jŇŰHĘq_f˝|ůp©úľ˝»4«ĽŁ’ď§f%GăÇo‘(™üÓĽ´_N”Si^‰Ěüű—á2u+u÷ ,¦¬•?ř `9#vřööˇÄŃ·ü2l<ŰĄýµËv×ČŰ̱4ŤNľÖÓ–'¦’¤wĹí‹ 'Yöô5)bϰ˘ăűÇŽ—óŰ.ż1 <Ýžýä ÇĎ ĎÚ&f/ý5)ÇB ŘdkŤJň~Kě}Ó7s§Ś9zç\AO®TŢŽęĂ źb}GgĺťÚÜ—¬ˇ~~ g~_|ľM Ő<ÔôŻ»fµ;ž”i\ëĐ„ŻÎ0y7˘Š‘Ë-ltw/:đ'«o”‘ @aĽ!żÖĤNLlţ±ÁlĘĘ ş¸:‰ńQńÄSŻśŠ/÷nŕmJ”fd§;>ŚóëÎ9ÜjkÚ˛ŕ-´’PěăXÇĺ$Ü'Ŕ}N •Č Ú'v7ŇŽFM?I­ą]Ż>ü´{ŽŽ2š5¸î°Y8Â{Y¦†¨íŮ”7 l-´ŕ?§˘-ôŇveIĘbHƇ]_KäŰç[r•^Ôo´W倚ڌ?–ĺPÂŚ ׍Á* óĂ‹sQ?>†íŔý¶'Ô¤Yh5^Yč‡ňq˘ČĽ^ĽěP•ÖW]şŔ$ĆĽÓ~Ž1™śyߍ§ď9=Śô§V0úJqą2g™ńyt ĎĐ>ÉܧzȬXs¶$°YX˙±p_ł¤ęyfÖ'Lîmpxů8Ś“ˇ%JŰŔpĽ)†ĐWÔX€ňťĺ3Ăň^\řYť‚ ö X ü­~4Ţ×LC©ĆN±Ě}ŔhCťă†ńÎ<ÉǧaY°łÂ‰óÁŚŔ©Şee_ó ĺŁédhcÜ`^o Ů-Hk!o“¬Éş®1Čâ‚ÉÝ٦çąö,`8sYăýű-˘ş\$ď˝ôăăR+uTş.zK•Şł¬žů¤P˙™śµQ…“…ę**‘é»5ßč…0‚bŁľĂwĘňŔPí â#ŰĽ󋑡?#Úż-ař>Ýľ°}Hr¶‡V™[,ţŽç;,+hĹ[o`mÖU»ŘŃŮűďqŁ0ŇN˝s*~ÚŤáÝäżţčúqĹŇęšŢVô˝ô F&éů+2wíŐ vĹňLj' Fł†w˙„ ŹÄŇT&­® 8l<Ih›[şo*ZC«×dţű:ëEĹÂ~†x+ 9f˝ĺ@ „ß9ϵBKfź‚üíţěŔZÉÖEr2‚Ö‡6báäÖĎ‹X–š]Ď ţ#íÇÁ˛‚«Đ{⢑ԓL ú-˛ÚľçÓnśW´c)Ţ{čPŞŕ¦C)ś˛xdJ­dŰ./oçŁčj"Ť( »ë·Â0d$ţ6}@ć7«#zQÝ8xI­lúţÇZ¤®x~ŤS1ń~Ŕ>ä9űDÇ€\]«ŁHŻÚőŇ6´ řDR®çŔłűY‚îçś íČÓ®ĎćL˘šÇë_qô\ÂťŰXíˇdżŰť0ĄóC˝Ľśd+MőŰëP×§ýÁTqČĚDŕ{NcătY±úDČHÁĄL g¤•\Éňo[äçßAtyeŤ|ŤđKYv÷ôE@ÚŮášőtÔ¦ÂuI’ądŠł.íŕ şrřtOÇqű,˛ő˛ÂĂK "« k?(ZźT¤)B2ô~ł°Š^W°É}2VĄ÷řQĽP //¶¨$çrůGnŻ=Î AÝďˇŐ6·P0xŚĎn]^®okzżOëĐęxƉÖ—áÓĺ'Zv–úŻAUKŠ”ľÜrY„P´ęŰCŕźnŚ…RuM,éH}%˙Ä5Cʫإkl±ÍťŠĹ—K=RuáI‰•#ü˝¬ů,°›_h—FŃHň şů.ÇnáĘúxś¨ďpÔ¬p$÷§ÚÝ`ş żŰZ}‹9ůT”=—{Ôđ˝K"᫇ţ°•'„1˝ąbk×ĘŞą ňď[ľ§ČiőŠp?”ǧL脹Ç,Ś!?ĚW yj±Őůßť-Ú‹ôÖ͉UsŚěRÁgŃQ~NFFŁYţP–ś–÷7ÓăTôI}˛íýÎó™-qÁÔ°ÖÄ/űťó5·Ë<.übŢCřÍ:Eâ*‰qJł÷Wľp»…đQŹŇđb9“]+‚eK'°€"xoÚ9ÉíŇij)6ęöý—{­TűÝ /n4íËô¨^*B«N uąAKłË9ĂłüÁ+‰ŁávÓۨĚć.6ßřHEb˘ĺ wĺ7ZP˝ÚÁîĐ,˵-S«T§Ď{Q+ý?Ä„ŕ{HtnhpŻgEË‘@Ó©Ć7´[ŞÁopňˇé¬id^Mç%.Źó+ zF‰ űłęÂÉdjŻŘ‚Je ~xť%çJ,b?śĆĽŹŇüÎqP[ŃöpG-$ámÝa›CT˘ŕ 0»O›6­¸p’UĘS{·őô7ŕŻđ§šŃńí~·‘ă´çżŮ:‰lPÖdSł\:@Sq#×ö%–@^d8ßY~„|{”«×I‚î(ă§u Ď“¶Ůť˝ą™JV(ÄËÍĚćĘÉ5đ˝|`t§ás@nî° Źµ­¦–łK jśňösO@®GËđb[c#üđVÓőń°uţŧĆĂ Öć¸ĂwL¤ ĺ´ë[ĺ ä]FtTҰŠu_‡pÍh›ŰÁ[89óăt‡ˇć­ë–,yĚB¤fjRG‚î˝Ńâ@ü|Kj’śĚ¦«Î+öšÖHo/ ôLq»)HiëŐ=V·Ç™*ő8VCÓIʇo··8H,<(Aŕkęzáż/"ÖTOe#ěpłWÍ ôĽänĚ—“č•Tň:rb›-ýľí2WÁ” .I'ˇt’ÇűČn=”Ü$1GŃ˝ Ç“h–ÎúD’’Oůřłv9™ÓÇN»˙ct$łŞXK÷˛ç[!aV^‡Fć·–n‹ô?‡ŢCBČÜ$*9ëĂdžϿ콽wBQ†! d|€ócÚëĽ%qÄ v.łäµ¸tÜZqy|^čüĚP5Ňeç$˘źěi¬’ )±™˘Nw‚“béO‰qęYnĺ×&˛ ťa2‡ÜµĘ”íŽHJî˛Ůg—±é—VSjAëdŹ÷żŘRŕIß™rAóĽT/đ'Šę×Čbď©ćďŇuműëJŃßa2ÔÍ7YžĂöR!˘ž=EĽeă_>ÄŇö+Ą9b•ďÖňŢĎE“RjŢ©ľá÷9_6·:|Ŕr`Ű;Ť=ĚŞÉŮ[w> ®·č0†.Ľ ť‹Ű—möłíř ˛ą˘Ýç°ń˘Öę`mĚ˙VĹó°1JˇŁŤĘǯʉJŤűą— R"JCübWŮňú1gŤz9,mY‚P–’Y8lƓޕD§Ćţcšv•°ąđ&QżČÔ¬BšŹńN5zJĂöńâvĽŻ±_ ‡}«ÂuňŽ«pgL#’\Ńâ˙ľ +*Č Ň;˙Đ[»˘ěÝ˝S‘Ű‚Ş3ĂUĆ^dŇí÷‰!ܤÎlá ţn~5š4`éĆQą ÝşŰÝŚVZ1˝ÄÝ-ţ$ë‚ú×Ăňz䎫P˛6Há×XZé,Ř%~7Í·ÂT$“’q,‘hĺ†Č¶a:­aś^ěÉ™mieŮŘČ;ePW·Új˝Ž&8q=%<” Ůđcş" ¦)Dŕĺn5‰ňŰ»,Ě„Ěs ¸Ď•y ]Ór˛ý±UăĹ×/]Ü~‘ű0;7]qčĚs3iw×ŕiAY|bâC§ŚŘúŐŘ?ąŁŐ ŠeĽíÝóŕŽGŃ/ŁBç°GG>ËČ;*6¦˘ŞX"ĹáűoĺF)˛._h ŕĺYέß3Ćś´>MÝÎ^ˇN˝đîlř­d{­ă{_ҨËcë@{FĹ1¨qDFŘÓÓń‚ZhŰră?´KéN®j¸hůĂ”źCȣΙ\Q»łeL7Éŕhrh¤•*ţxńĄŞ›”{XĘ›šˇ˘«VĂľ˛’jËoyćRTÜGĂŽĚ€í_µß ä­Ěľ^0f KK¤ÝPž/ÚŇ. ~©”ÇčŕN3-č7­E࡬>éŢ0ç?—°2#}‚÷’=Ť•č¦Ďv¬S) Z“¦X=śśŢĎO©sŽű“b aâÉGž}Ţv*šŇľ%ŽLJOíÝ98í‘»Ţî+×jÚö¬ń ´H/‰sŤňî€ ŠÔBTTńXęóü©Ű Ńqß*YOpáy–[ň”^TmĎŚaŕć.J\kH XěíÉHâ«Ă4"šr¨ĂeČŤ$ţ˝¨ĂÂ5AűCůĽśî{™g úÝ–jÝ÷Fx0ťńŢZ6V“DÚ-Wâ=tĹÂĎ Óš”›%ĺŻŮ(ú@śO šµ:rľÝÚŚćJ“^ëŠ1łßÓnÇBâLNŕ' O‡E¸řGě‹G\kZóRmTďřźÂ~Źú8évq~łĐß•áOđ߲ęŽě=_ú‘SĆ-Ě– l~/yLy,îXč/€NžőQ‹ĺbh”ň‹ŔýÉĎ3‰Ý1ĹTŽéÓ©0ÓpěÎť‡^ř™ËnfŁH°3–¦š\»\Ą>\‰Č+¬‰cöÉf"pĆĐb]-;ąe™űąŮíş@Uň}”:(lőô5fWpvŇň‚­öőĽt-é$Ďktç×rÖ(Š9Ą Hů»ë!¨ů ±^˛ů2ů4âá˛p)‡ sÁYZ„`E"b´~ʆqĐ’{·ĺ“aţEĘš2šQď°XŚ$Ű\|\ú9[Ş}}áSČuAč#IůĽ đR™ őŘ´eC™;¬©ţřpˇ4ä»Ţ2ݧxV¦ĚG4ĐY n''acLĺČ˙ć´źŤ5šŁ%ô¬/xÖËcÎÂŇ•+ŔĘ1ňSžËĺ)wJ äŹi‰łńŃ®”rÜE@ě Ąˇ¤ŐF~•9#Ú`şÂ÷%»dNAóË29Üě\FC×ČßîHĚâfĂ7Ä—•G‚n_? \-‡°'Öą2ŢăxÝz1ߌBK1žĚ&Ě }éôŔŞ:UÔR×&u3 WjEôD¨"Ĺ樇¨Ůd'8Áe@OdýQ€úŢ˝µ AŚ4Vy­ë@1s Flźőů€b[jSz&ĺ{}˙>—tý=ľmKÓ€Ę8ĺ’”·ą”ŐTśH7µ í~?[Z˘żÜţ˝šďŔőׯI ź'ÇÝ@Xţ>QźřĎďž26ţ>ÓŃč&µď("Č© 6Ůľ2d°bN†1‚ţ&ţť‡áiű…ĘŢDé|Y'KíżĂ·ÜMĘŰĎ/­¬ęZ¤A¤]Ű (0†Ü»´šĐLÄ ˙ba —eČjłůęÎ ÇĚś©Ă!UbţÁč 'fâŃ2c>#hÉdi"Đő†Y‡”VţŞÇÖ„ŕŃ^ĐcW’ŔbĆóîĂI)ŚUśÜ űBLć~‹_7űMSźnĆęD\¨Ď¬ţÄřĺvŁó°ë‰,ď#‘DţiýŹÜŔ«5ľÇ.ZŚÍĂŠ“Č8#¤•ńFö…#đ/řy]\˘ řřÔ‘ĂčÔ#‘wBžŞHŕYvýíţE”öL.kcúźl{¶|É\2ŤJ5±n¶[ň}–“‹Pé!$±äŁHĚÚ>§Ű 7z^dÔ:‘ORIâŕNňôČqk*ęň¨ź> ‚đŚSÉŹK¤eBůkçj†fžékFşémĚJUňčŠ_LC/rşúź@Bş›t„ž†rř:éaZônţÂĄL·Ł°L’"Đ×ńo±n«Uř~´jé´poxa¨äîĚc §PŐŁčřŐMęĐsŘaNa2óAjęĚcç ĄtKiZ'íěěéwĄŹ(íÍ›‰Ó9”3醌®?™Ý6h@ż?¬nd†\CΖ‹Č+ôj&Ö€š@ÖŢ™!ľä4ökÜ k«…şJ뮳ôg–gBNŔŹ© RNÝmwšŕ“Zo“ c­v‚¸E7tnů,ŻöÁ©(¸ŇŤ®2‚ŰävÍ`Ú%-ÁĽÎ7 ĺL35-´Żż8gĽ•‡4ö Ţ)jIP@+®Ĺ»‡pĚ)× LUĚ"tÓÔb5…Iç¸f€`łÎ;é?\P—(ťÁ´»Ę (ŘVGé>ÓĹ ‹T…gÖďÄ“`áR—â>~zćwMTÄ ďÂç&–ß9çąćgUÁVÍĹҬĂůD@Ór0ˇĹňďŘÇsZ­»ŢĆ~?^úőóNąs|Źčf= e?Ż—<ŃěŘÎĺ7CĘ;3ępćλ8ŢŞ’í1RżÉł*ř6sf–ÍÜBróâľbҧ”Ř#!#xe\ťĹĘV”ڇ}q?7¨o'a{ÂJyhuĄ6x¬ôÂ7÷¤#hUT)˙—ĎČŁ<7$ăť—™Ň(Žş%ţi”vM?%¬˘Złňž™ůWMčäiK0ŃŞ…ňźum«V)/·*Íâhx«Ţó1 ů:1›őe#Đ®ą Ţ‘tz(36A–Uk9b„"ĎRHݵßĂ@|Ω0˛:cPń~ő´Ęç€˙TšůöaÄÖ»ů=áj<Ňcß4I)¶>?G f‘’§z8:00B8­·`ś‹qßČß]ö Ůyšuž_NüŮʰ1ü,EdŕŔ­čEůÇíµłe rµJ@Ŕ—íQrDuÝô„ż,łTBÇ–ż•-şäĆ$§§wýAfŽ Ű.UY_7CŤëaaKÁâSVť[/°Ŕ‹=Yő['zÜۻݩSoÂAđEIýéĚń¸EV óͱŚíĂić ­ňSqç@`Ç=^ÁuR˛3™9ÝrŃł6ţčšĐ–~±! ĺĆCV‘|9đ™•*řä.tÓ„:ŤŰ˛uŘ…8ş›ëŞĘu§ř&•µÍő˝:GřHÔýÓF &áô 0uŤśt"ţ<{M}ť’]%ą ±ňEŇŇPŮ·×;öňţk¶9lĺô ô…hKú =S‡ĺ{Ł®ČţĎjî. &M`6ŁůÍúAĘU`ŇćýŰněp\Ö©r“ý#†ëöÔZßőWČ÷ľ3ÉuÍąĐ-śbŹ("~K}lÝÝľc/É’Ŕ–ćü‹ĺçÁ3<·1úbYĺô{íW„<Ç3g{MúYä‰:ëö,mOMz¬˘řjă~…9¨ µžU®”źżüxźBś%Go]ű˘˙ÎăţX(é'1ÎĂŰ-”&@çąÝyE®ß4Í`¶¶m!7Hđ*—ŠÎOُܠž†ž˛E–PuŇpž<ĎtŇ·ťÚË©‹í@dŐiăÖţg/ÚÍ›™’ĘTUHh~Oô:ćßTĄˇč m„–ůü17ŇÄb);ďEáĐ34*y˝0ÂţG™°ł6 uç~K^ó·jĂ š2üŞI·~ŔŁŁ6‡Ďń°…FSXUy9ĆVĂŕ!ŐĂ3‡ŽŁ°ĚλęůtcŤ´|Vă(›Ţ™yŽFŢ x%SĽ\5éră~JxÖÓ9µ‰A¨»eŠ}šĹÂ÷č€jća˙ʉ+$âŹxJIĘÎ(„Ś{7ÉŃ8Ź˘j*ę§*é˝A´U!|!_ŠTk†ç&îŔ"ÝeAWĆu…VpdýhĹÔ…ÖŽvŞű¦ůEFPyäŁaódĽ ™ňPĚꔥéÖbĘTe‚Sč†dźÜ—VĄ×ÁŞi Ëĺ¶,% |exčÖz—Ú"‹š_m@.lŹňŘ_Â9ÁŚ>ä2BŮŕ±VĚľ \=N‹íŠsz¤Á+"HZ{k˘űgŔ09߯0y&°U%ă˝dOÝîŐëđÂóF3ĎRoMőqc&čÔF\€‡*s`ĄFÔťTöÇĚ_đA˛÷e7Q(ú¨ÓQ—ŘĄ$ÍNżúÎaÄ•`l? aŔA˝p(đâyŇTŰAg«óg XěhőXJůł0¬ËR'Ęt*•ŹQ¶˙éÝ”Ç/<}ťłŁ(»°‚rś‡†˘Ďk3({69VŻ L¨-ËšĂJűĘ őéÎitĂ(SŢz‹DJ:ąSÁSŮ|Ä[FoBńµkâ櫤?ÜĘź|&W‘¶jďRŰ6ѱuFöÉs4b8ÉßNhSDŃ B?H Ü=Ü ŮKs‘nŽÜä`ĺ/DáK*ç…Xb©ž=HÄ95ŤNĚ«OłÎ|pń ŕG:Ľ¶}ß9`gż{CwbfsX‚]ţ^KwĘ"G€çŰ-Öp%’ÍŤĐé`wś^Ń C“˘ˇëdkPDĎmHЧéSť…JăGíŻ ŘDµűčďěöŇĺm(făZ‰oWĂą˛¨Ž<ÜF‚w5–{N~č‘+'ĎéAЍϲg5›‹ÇÔe5«Ăë†Xh"ěJ\Ď´pz/Ůu·aôłIٟغ—OȡB…újIçí˘µ-›Yş›ÚéC‘úµĄtQŢy±Ë˝Ą1ý×Ó‘ż`ɢ…,ÔO˙ÍŠĆä Ş°qą{ôÝ §ÁëîłÜ&ĄB~öWú&ąî zĂŠ§}Ô^Îél‡Aľí7î»ËB¨»8j¶~Ý“Ç{5űI<ą!ŰEzh`*„Śď>užĽ ¬Ż~AŮ%äźĂýĆ‹—ŚoĂë(1·á4`ąúQEĎg {É [Ýť¦5őlÔŐ˝ěŠW "ó’Dč;ă±c¸µBŠşÍ*Iv5«—>ňŤ™B"(Ą–Çt}d<ˇźzEGÉţá5™ĂąMĚ‹0€ÉŃë6 ˇ%?CĄÔ¤ťĐ|{­Ři7żemSVq·kóU~ŹmT;ł÷ă0K@‡«úĺ‡K=żěžSŐÄ:ĚĚBÜ*-ź‹v,k]ö&Ťç!ÂÎgĺS.‚X¦Ra#Żífâë;—‘Ż)óMʇäçÝ9żâ±jůĘB‘<űśk^Đn‚×Sąí€čO‚ϵńHt¦%E‰ńéśů)„ˇ˛@)_ -łV¦aeü»MCß9ŮtÚ,RĎéŰ7ó§Ű7m0c4çwŢ$ĽdCv%fű‹ŐoéILҧĺ;´Đ`ŮtÍěß­ęŻăçEĎ~Ąćîd˙E7b©Iô^o3ýŐb«r‚©ÁÉîđ Sď=)Ń śĽkŇ˝Ě~Ä6!¨Ž÷˘¸¬ Ë-‡´ş÷ä‚Aw'#ś—{ađÖ~ČLÜ[éo żĂŔޱďk2ćí LĺžsđW|‹1p†pęŔr»@AâE$6ą¸ŻÍWnŞr°î Ş>ę¨Ç»Ë©˘ľČaşe‹˛Ăf¤ž]Ť+Jń­ĂE=?çv§ÇÖÄvCŽ{_‚ ŇPł˛auƶŚńzq÷ ´x­ńa$9ŐS îOřjqŽ«ňˇ.JĄ¶î/Lî‹vĐri9˝ŻÉ¤ď„'ÂöÖýô }×Îë“*.ź|6X8JǤZF"”çWÜ·YX‚źÄ˙¦Ń«°ú3Hł^)¬dŻźę©‘Fűü›Y#‡ôÔ@™VěpžÚ‘ÝÝ>Ś.żˇđ/ď/d°:6Ió8l ýÁź?ü°`ďqăł… E»ţ2»{$CŞ @ô|¸żpí ˛RM¨[«ŹSIî}09Ů–)ĺµÍĚÜĚs#Ö°ČőBÇ:ťˇşSă4_…pčWTPËĺdOľ>s_•ë˙=cqEŻ(ŢŐÄŰO~č ć¦zCß!Nb±„~ąGy3‡VĆÍⲶS‰©=”Pö4 >,/=Ót˛RäĽčże·şZW}Ś‹v€`’¨xv§ą{IňMźľB˝őDě …ŮOü;BJ{.Eśë®«cE(Šů fXĐ[ř„´‰řólË÷‘űÓčľÇp‹…RŘAqâKĹúűÉŐńvŰm_Y…łSí'źö‡ŰßĐÔ˘şĽk‹ą‚xďž~ŽIMˇ?G>F‰ž]'ýÚ`ü°ż’!Tpôk¤á&^°3 Ĺl®Ş±M\Pł2h&‚,Bá™y˘C±8“rkjÉďH—†‹*TĹÎ-A4ęx#&z­7žMdői5xŤĺÇRŰ 'žE^î€91?:˙2Ě\<Üýéjü)âĆëöCpšä uĹ 6+r.vyKÜâČń×FU^ü}©?‡SŃą‚]N'g%ľ Ę„°óU«şĆnź-Š1Y»â/ױњÁ´ú©ő˘î®&9cÄ ¸3oD\tSQĄúÜŢÉ8†Çdűč©›E" Śű)•ú‘ň˝ÓSóżÝËqőŠ&Ůć?+ý~ň›Vb!^óShËĘ ďÓÁźxˇźĹ@cŮš\¤7†łŽ®M™żŽ.Ë~­ŤŇÔ`‹‡%ľ9Ěçky>­Ăšp›EŁsňÎ!mÜČĄ zg*Ś8…úćú8ě!‰’ř]o`D,Ö÷rýÇŽ·ÉJÍXĂPزłÇ˛Ź ŕÍąęač ¦ţę!Ψ±ü|4±^˶š*]…ˇ¸ÔMq]Ń˝ü˝É‘áÔu—çiřâ u‹ńVkQl5üŇ~u/Ěyvő6*yăU]őł6lQKc+ q.NľµśÇóëŻ5‹ěcO`îřžxÉÚ?K`+Ă%BĄĚŤčŔ8*^ů'Vţm:¶5¤ü1dp>Čú¶ń¦ ΤeŘ1Ń*'“b3Yt thóŃsµf˝^™ŕ©×6ĎÓZšDÉÄ• Ů2”;Áó+‰ŽĎĘŠăua¨UK-v—äľl)@Ľľ’…»OşË¨<ö¨›â ŢÂôN gf1d=‚^mŐsmĂđX9íËľÇ ]Gµż»™˛}6­z]zQ˝§×‹ŚněłtX8o.éu” ~—Ę0#,Ŕ›śŻşg š-pś—žÜJâSw—ŤŞ]ÄLŤ¤qs˝¸+B´ě ÇąóűxivǶÉŕH‡Ö‘č軚‚lÂQ)·ć]Z.­ł1Eî·ĎÁ®·íŚâjŚčš´yj+“ý0ćçá“€,©2´ěÔ11^’Ý5××·íßŘď ¦* ‰Ą‹M>! ýÁ` <®;zv-ŇÖS¤:-­ZĚŐÎQ±‹ÂtŐ.†"lNE¦ç˙ě($8ňüŰ!ŕl3 0äÜ3ĐâĂÄőÄ'TÁţ$ËsX˙‰®úŔÍm lYÖޤáNä –Ś¬*g8(Aô2!lŮ6ţ(k…ĹYÍŘęr”H©«;|dŚ€š?˘gŽöçÔ¶ř$K]Í)ŚŠ’ź —ÓŐ´§+â’Ňîß%µP(ż¸}ÚĚëľËz¤oťÁ#;5,N†LqçŻÜ ŚŇÇ€7—xM— Ű{#ş7é (! Áä¤kCYŹÚą·R@äó!Ma0÷ëk<ĚŘż…)@÷öZ3Me^áhŞiËxúÍĄ®í··`Žĺt5mţŤsK˙@TÔ™†zoq‹H&Ü™b#RI~u&Ťt€âu=/đŚą:bţ´\ΧbÂĽ‹ߡ]Ĺéyču‰-ifťĆŘN)1~lE‹W¸egĚ3TĢż÷¬ţ'¦‘Ú—Řţ>¸‰lq!đŘx!Ä?f Z^#ĚLF5˝ýH|>Qśđb‡ĂÇ]ňń—ŇÍß~tí&@ż’±ú|X™­w~ζÎ]AüŰ>sÁ·cR9¤—ĎĄvžHEí7¸Ă2ŽLL'N÷÷†×‡şVj•Ó5Ôî•˝VmTeUÜIąˇ(ÜJ¤ ŢŁňíîIŘŢ7ÄB)őĄ›I>™€4ú¦—íĹ1Ał?—;±Âř8+cyď9±usĹu%VKCÖÎ!‰Ű˛VöŐş ýčض‡ŹŞ-ŰÚ˛¤Łâ"˘’Â${L‹®KÎ3…˘c Ę8aIŞ“v^‘ň¤ĺ¬·±Wńä&[Ź˝’69©„ÔL¨„ąäOÝ„jŮóOŚÎŰi)5ÁŁjj›wťs#řFžˇ2Ż TbćřpńM5ňÓW!ĹHlôăňFHX˝Qń­Żćîpć…g@÷3nźµGŐ˘gFKő¸{‚ăţXv2Nnj˘“ŹxúBB:9ä*JYę_e;ó÷ilá“á|쓇e–2ÓĄ8:®Xч»…‘Ş83¤ĚÉĎúŰŽ•Nw)±OH> m6ďfU†KŻYâtß;mq›ŽHZJ_^=ś(šÉŕQé¦É+7_Çďę˘öh6äŮăx6ěË1F(Y3~F§=\śĐzśHÁjSRzX!\=9 Bk|ÄČŠí»ß…ć ŐśłŽnjO|ŮB·üţ śhŽín)„¶o†D% ľţîƨ‚^ě”"snL°…ُ…:žS|9-ňş¶śB‡e+]é?ŇîAĂTÝVNś.”žrp_›B’Í40•ZüÖőá=ŃyĆ<ü%l{íą~¦73Ą ŠŞ1Śţ–¨…ťZ´Ý> Ęjń{f:P‹¨ĘoŤŕ™<őd˛WńŘAHq¨ZaÓa伡;ăxăĘ[‚ĐŽh3Çw'–áę¶˝’S…5]ś›ß~B š:eGăݡ¤)˛KŇť=ę§z[?&FbVđ”cÉÉ OeZ "Ţ ©Ó±9„üvnłqmńꄞoŢjńŃ‚ź€ŮŘÖˇWbYB}}щźü›ˇŤ§äšg~ËŞnfţ0P®o ź®2ĺÁS°^Ąźd—H±Ĺż“Ëőˇke¤¨¬ŰK?WX«qPś °•C!słř-"j;7."ÇuŢÔxĂOď;&ŤQáŠÜ›9dȰÄO°ă«D»u+«/iâÓ‡JÎżÓĹPŚÓ5ş˛ŤK ůÓ¬¤˙ćIQ ç…1SÔgžúpö×GL8.  ó~Yôˇp[ˇT×&ĘPjÔ ‡ł±.ŰÓc€ ­·Ś}˛]&Q/!o‹šŞ{ „7˝Pe^†±~ľG66l|ŔYá´”ë-[!¬§ł-ÓPËú˙ŕż÷vr űMpčjNĎŞ\f>ł»ú#Çç"…up¦ú÷MbŐ+R:+t±ĺÖH…]Ą ý0R×%»69J”?V`4ޱ… X9жśy«Ę…Ľřď»ó­AŃ_ sÍĘKŁ5ś±ú_˛~Ź F-bZV¸‚,I)V/»¨UőßđŚą‚Ď™•Čł3TŃň–ϱJ%¨]B¨|c‚l¶żţřáJ@ 5WťÄM="—ˇ&Viľf¸>2żĂőúY^Ű ס±eGŞoh5©LŇĆ»ž .*u"Őöí0Ň'P^}wI´¦ţ·U´R¸"źYnpŃEv¤Ę­ÔßDÜčiŞ'óÓ‰ôÎ,­F•n÷4é7S&ŁĽv˘kh˝ń$'ŇŞ|ŞžűQč-Jč8UŕxÂŘo•dŐ@’] c,˝8&¬Űś" ĐîĎ,> –ĚĎ®6®á¤˝ÉV„ډ Ëů¶I1ŘÎîi漫ˇŁ$–®@„Cm¨ď8Łp¦Â\xˇäh‹ioßߌ?K„|“ń„“Bu° ßž´o'ń ržśSrĺśhňZA{ę¶Á;Š Ĺč‹ŮeĄxy˝EŘo|Ţ-ô)Üű.Ý{seg¤ĺ ŕë&Ë\'ľ/·©?ř)ą)Ů ý­ę™?ÎŮ;çNJLĽCЇnÎZ5/a_ŞÍ$1“°+Ś/c‰§ŁćV’\ü ·?űa$3éW>ăľ6ˇOąÁ:–%Á×ümíNt§~ů—@HN‡ę1ććˇ~4 eˇnž7âŮŃî%cbzIK˙7?WĆ_Qgĺ °IúpŻ®™KŃbŨqHş $rrS•ą;n„w#˝#H@vT ÖĐVł©^ \Z]épŇy•ý™ÄL— ä–‚¶>(L ĺň!žÉ'Đ„1‹e™”™ő0ĐígĘĐ‚’ÝşŽy‚pŐAv—ţFDCłĘµł޵5áŁn‚ćš}ńţśîŠ´ żđň.8Ô©8 ĄĐ„ř.!‘•só1´4!'Ť^łwďyé˙¶»vŕ #1Ló=l´ŐYŇŻ»Ł‡?UuĘ稻Śö0$p Ľ_+ŤÎ řh­%PYÖ[JŹŮ˘LKá‘·\O­7“ź‹f©W[o ß-ĹC‘Z9ÚŢfeř;´ÍtÉv^ISS<…?˛‡¤_¨[[Ő„ śłŃ-p0ą z›ÁAËő%ŔŁńEx¬yň+‡ŕżZŚ’ävß®Ąě9/+’ĽÂ6(/ÔDGţ=wć pŘ#,wIĹÉ,«CűůWŢ} ˙ízDűĚĎšřB«(z•\ĺ:Ćn-ŮűěřřŹŤŘě<ĘMµľľöŇ"ĹÂUöDCOď†ďą4€Đ´)lXâRť…JN›ŕŻÉH°ú´µr bZçe3q§~ !řutŐmÄ$TŤĺ‰#ň¶—ŞŘ ‹jó"Żş± X1n łFTvTÁn׺ş­%A˛Ąř«›ke/üş×ĐŚľŚůONb6“2ú+™oöÚ§HCĐ÷T—N"ü<Ö5>2v2·b…PDą "QčxZËŞ®Ś!˘nßQa·ąaŻYŇ闚Ѥ=¬ž"X´®m~5Ë`î9‘U×ő'ú ĽÄ_r-)L×DU ôA§ý\’z3 @čc‚ű¦ŕ4đ—rLí–aŇżÜ3#CäÖě$Őωß÷!yB«Ł÷Γ :đś){ďĺzŘč§9Ę­xճΠţiT|{żGPĐ‚«®}âT÷„”eśoKúĐX>¦\sąr~ĺZvO äň®şŢ=±ŹŐł`nt—+'€IA ů‰B4ľ’™5X¨´˘Ćđí" Ţ˘’üFŘľŮ]S3YôÍŽýĐíŹI㛕çâ^´ÁyžDFóMŰlCÚ=:ËͲýÎâčš6ů†(ťm×:<^$‡ÓV×W}uř–‘„ČPűęÓňÄ/s¦Şś´żąÖ>KşPą»E&™\Ć]ëý×jj¤#ҤJpĹo˙¨ŃâÔű™öTUľ^ň ’›Ó˘ÓŮŞůËË,I˘%Ý9lż!dr7`fZŢMÍ~şÉM‡Q–»ťWvB‹VČiú×?އb*8ć1SĘŹOgvE¬ąwI©mîĆÍ–$<…ë‹ 1ěCŻzBŽ÷K^Ă·ě\XůĚžâ×Y>ç˝ĺŕ®uTň°f ěű´űŢż}|?iďým1iH±‘ é4vt?ó‡pqJgfXŚO2Ń­µŇjvc9ĂV­ILD]íę>źřtJtA5Ą©ŔŇďSDá"i~];eč@Őĺíżͤk-»âGhľZ$©wNĚ5?DT^ hU˛ ™üılˇ6öµĆťÁr †ŻŽdcÁ‚NŐšÝwýÜuU©éý{ĚúaZřd٦±xŽí…SťłÎ 2˘ň‘`ǰţRo2Ť7]·Óéť4%ídg@¬žëp1Ö 1|¨ý˝[–7<Śšeď–ę&í˘wŮ·Äٰ@PcÜ,e‹äâ¬×sÁ3Ĺ ä9SKëźňĘÇc×S8Ú¦}K›ŹI’M™zÝä-Á?y0ëĽFYD!m™Q} ń„ЦČsĄüvŰ‚á3ÇÔeĎî2i·¨i”˛ĺx»rö¦*±ű^5ŃéR,É_ŠÓ }ľ#+ęJţŰ9áîőößUP·;ŞvzÉŘř(şŢVpâÍg´§ćr\m2šÝŚ8Ł˝ÂoĹ|ú¨7Ĺ<˛—@÷:i!eń÷+ç­ě諭“^ŚđÂXŚÄçYŃ“Ű=°ô€p˝­ý˝ŐĄLbŽsô~V.»M™řQŘ Fbb‘$§TÖ‘‰ŇjrËĽmC~†–X níEÄDČz?ë’8E[ůÉ!ó0čp8Zg[ÖŮ$›če­ĽV&Ô‘Eꞕä 3®F~…WEŇĚý ’Ť<@‚徊])quL]Ž.@Ĺe·<Y.“ĆŤx"ś­`ÜK > ęňD ŐúVŕ•°Ň1´ůTż1d;ú˝ÉnZ”• ŹçޡŢpô|ݦŇÍé LblNŤ˝éđó‡5ÖŮx0ˇÓµ6nžŻöXkŐ±˘†ZRŮN[%üßô×ëÖĎŹ±ON‰Đ4ü˙ZĄřM1ú´°âżŔĺ} ó@*´–ÜgÖÝ­-č;0SËůQ›žFe0ň-čg¶ĺ‘ňDCcěśb‰‘JĄ>jokŰ…y¦˘Ľ¶q))ˇźÂ˙ăžI ]č‡Ď]˙Ç?ô=Ő°ě„•PF7Pä㣺=_7ÓŤ¶ś@}Ť3…±JBxÇÚ]N¸Ň8Ô´TE ĺ±8#”{°Âwçxą@ ˙É*XĽĂ2ß|8űĄĐpÇ»#,dŁ™Ő*ˇ;‚Ő›˝7vWlí<_Q ˘{Ę! ęKććâôË›ptË»°JĄďĄ«°¤+ čÄłt @~® Ü]ł˝Š«ą…ť]ä™M@ ľŔZÝ<,ŢRc?4Őą( ů«î68wS÷’k.ÚT§EcżwĆp´<TYę%Ę2źôŇ˙°…ÇXăń6$Ź ăţ 1$ ”ą[Ô°Ű*IÇŐĆwd~‡Ő†‚bő“É"×ç'šMç€Ĺ/ţkąË- Ş˙óYö‰ń<ç¦é /pęJáw”@}‰ž|„ĽÍ«Śň®[u7§tÜž(ĘÝT'NζÎâor–‹}ÔjŢ#3?ى­0żé –§R)ĎWĹ­v:gť˙műlčúÂ<÷|#M°QňbÍ[ZF,ÉíĆŻ ý—›Űuý<ŔÍŚOšŁčß®±¦ůTx=ŤŔ 箊4§„ó°!~(Dťüeü®ßĺ šŠ^˝Žâ\‹ĺČţ?Ú¶˘›K9 gťŰu"ovh˛ÔF!śťß¶˛~g×ÝPąő"ĘôĐ DŔĺ«#ŔĽË#3¤ZŁhiČć wŃ‚Coë{#›ĘĘűÍŢÚýÖ ZOę»@ŕ˝'gją° b`PíS@(8Ťö ­?fĘ=–Î˙Ű;¶čówMmľ‘VŽŮ×V6ł­Z›óŠy,ĆřęŐćßí2J©ms=0ÄÓš,“˛¦:‰Ŕ@łäĄÍŹ»Nľ>eKżi;˝ľ…ł8^«‚ȰxÎwŚoČg!ŕW€Cś¦éÂ."lnbPpNHáa0 ˘Ą±Š`•Cąö§éúÝyös@ýâlG3ůźőĘőÂyW©{Wßß"!DŮŔ†€ĹP7SÖÇ6{Ңǟń2ލßůË®u˘]îŤîíźĎ„ ¨´PŘyÓZ4îZ@&ÔFf\[‡żÉxÎ ˛ľ±]îz±×(Íáš˙ůYĐ8öŮhŔhkÁ~ľˇ§pmiM‡)UkˇZ`Ţm9›Ĺ5‚˘^YD1–}ĺJ¸kÓ_a6ßĎ”QŁű¦Ś·i`˝›Ă«Gú˘ĄZ3çŠŰö%hÜú©dx…w‘EŢ·łq2›aĘf<^ď$ ^µ!ŽĹČNg$¤$.rh!&;ŰŤ„źĐËCéŹÝ»Ő¨Š|{›‡ äW™żšIŘ,ďW+JŃ®ŔŐľi!˛m¬/ćaíěHÝĐmOý J+(Gţ®Ě$(“ŮtţÍƮ͓¶¨ÇCšJŕĺ˵­tďIÝÄä{LvÇűěg~“‚+ÝDͶ·AdłÖëŤŃĺöäôË<ŻŃ¬äůU[Tzřř\= !ôsŰ뀨í@·©aě3‡¦dç—îŤPNŃxZNÂ0*×Űd–éÚ\Ki걯Ţww€8Ď%ĄÝŻF"¦é †N$Ig‹L­ŘĆ,Ȥ‹zU»nŕŽÂţotCĺW«LוÝâń żu°'>ţ+FlµşĐçQóVŕ €ďĎ †Ô’gç%Óe şyIŐ“Beż+CÚ˛–ŤSüżý *{ţge‘÷űjQp¶ŕô/?IÔó˙˛ ,×ďŕÍŰ@ęH4ry‘z}Ą+OÚ0ŕ—ĚXíŢ+âĐ ń gJ Ą|tś›Ç§oţČÍ´ś†^©ä´mYíீ9#xz#řä]XIFˇ0´¦Ń×„| Âb±)`6c®BLOýOĎw|ˇĹŤ;ŃFé9Ö2Ölv~uń?$żMŮÎî­Yż˛B%'śőWVFn€Ţę—sŇ‘ę()nAd*Ě ’†w\e\`ń^;×ęW“¦:9ŻI‚˘Wałúo”*ů˘`0˙rN‰¤Ö‡V‚G(‰×,—BűăÉFuC!°¨ç)Öx Ó’1írŽ Ö»Ŕ6Şâ>XĺcŁ|ě™P¨lÄLr¬ţ¬ßEĺ§qY窉ű1ZÄ˙ĂCÇsĹ}!BVőşč‰EŮ“čŇ9§föE˝56Z»BůÍ““›ůKĺ~¬ý´fLÓa»ž¶×¬©Áôx‰ŰÓ”Čb['r‚ČZüÂ[= Pa6~8ڧÓŃť=ć ´UĎřrČ})Ô±í“ Ö«6Łbú×ě¨ŃEhŁ•ćú «\©°ÓŇ‘ZplEłÔË—PŘ©†ŃÖ|*îřČF ÁĐB1ŃPř]á(7 endstream endobj 251 0 obj << /Length1 1468 /Length2 9240 /Length3 0 /Length 10218 /Filter /FlateDecode >> stream xÚťwuT[}Ó-®Ĺ]Ü (nĹÝ%@€ „ŕ. ĄH‹»»·+Ĺ˝Xń"Ą8´7íűÉ}źďŢűÇMV˛N~3ł÷Ě왳rX´őxdí 6 %(Î#ŔËŹĂÂ"á`(D=(ÁŔM¨@ ţś_čą0âBáĂ=ŕ_W€ľŻ řІA`@W„]ęć ;8Â˙€ ŕ qó´q{8‚ěŢP3ŔĆ÷R…Řňrä®60°ť !Ë‹@’uqüEňŔ@ ČŽ÷/Äl‚ŔÁ@¶Ŕ uAp ̇ţ`Ŕ«Ç PÖ2TÔŐÔPÔÔč*ęéëŞĘë+*tU•Uôő>úŽ`€Ôî „pDeö@[Đh;O[8aD\z!hůáŽ˙`ŕâF Ůyşą€m˙¶…ěŔ¶.PO*˘f¸#  őÁ ®ţŔzxÚ8 ÄEÂa`Ű?‘ Dç<@p€=†ŕCţĆ"AčţBüi¨$« äĺ°ŰrŘ  /7B1QŽ?©y;‚  Űßül\}Fä÷őżŹţUĄÇź PűżF-…żčžŻżś$Á˙ŕĺúS‚ř_Qv ‚U@ń%‹ĐÄĺ/ąÇ˘˙é%Ę@ú7?Ţ?âÂa@[8Ćç „x"D€#ZűÓ©ĚËź,DJ` ‡0€ŕ˙!ż €° ďżÍ,h´Ř‚!ÄDŮ\‰D”űŹÉ@¨‡ĆáÁáű3çŞ{(@ü_ǡ˙Ó„ô_u ňň˙Y'Đ qńŘěqř4ˇp„pö˙ĎÝř?nÂżíď?•<]\4®Î˙†’wÂUTá@„Ü˙#č vńýżÄüÓŮô· vM(ĚčňOëżd!@´ńú—ěˇöŮiá¶Ž{  b’˙ž@ě@00¤ ő˙Ý~ńŘ+jë yxž ü5Ł˙Źý­€OAWEYO‰ë?Ň—ÓçůWN˙rÓ‚!đżw/ţ˙ŽűŹ»ŮýÖ"–Ń`ĆŹČ_áx˙ç•Ĺ?h!¶P;0Ä1†uÂěţëŕżĐää >AÁgAˇg¶ ÄĹř˙ĘÖC(úwľĺýço{0˘“ ČgijË©B|_óú¦8žÝ‹V˙{ŔF;UíőęÚ_ч—űĄ­FQCĂHĘCcTµŇަM‚E<»k[ÍĂH?ń#DwáÔĘ˝¸ÎďŢ3Č»mR)Q%߬kG…\óá·7Sě–*Ĺ7,ʰĎxŹ÷őo‹ncŘ’¤Bt”ú˝YĘ­¶ ć˛Ô,aä:=t†ăăłwą\[A¤÷mŔ±%B¬üńÓ<çHxUĂj mbě€Ĺ›Îâ>ľI}˘Lćĺf>ěŚÄ ¤Ő(Ö‡ąJŚz»_çÎ Ë]Nmb\‡ýíáˇŔ_B͇÷€<Ě„©_ Ä%Ri“ Xě5KĆľ‹QŞ>ę¦ŔřĎm.¸_ŃyQ(هëË>ËlŮ+‡NůwPmwÇ&­űđşQGŽůüˇŤ­©“.ÜN§ĆWďĎX‚ŕZ<ߨŇĆqÍâýPŽ’Š\«ŤĚ:…)áűńâµŕĽű;)ĺi§čżĄ1ņ‰văT`vpUůÄĺ­ŹNav2Mý0{¤qƢJ~ýŇWŠsaľ‰źr·‹ŕß{Ş›„nŇŠţ.ŘďĹ®řs¤ŚC âÜö¸łRiőÂ÷íDK<u4.AÖ˘öˇuĄ ¬W'­6Ý1IšGCż•Ö´\~ŚÎXžÓŞ6>şm}Ş6‘§•n‹˙˝™Ě‚Ăv?ĺúŃ>|đŃé9ß—eRXc šŹ7€`„>q}öËtIPđŞî[¤4›ç€¦ĐňDŕ† ńŕ°h”đµ÷×›ö‰tYťäh­5ŘĚ‘çJ ÁGę@–›ci#Tjłżá,-6ú­)Ň {d<ś6 ×~ŮVŘśS,P'í0ą\Cćä-ęĂ—˝ŢVĹišĆĚ!3xB×ţĹ ¬ßmýČťĘőăú˘ď×~ÓÖ]ŻŹ÷ĆÂlË©’XČťô¦Éă”'y/}!¦wLâTĄ/>eb`złŹ„P0MmH‹Űi¦ř eóËç™ĺÉ A,ĄđäÚ6ŹUOŁ sÜřŤfzĹ ’±ěą‚˝i°ö›îD,Ţ[ń[SÄC1×z•ňQŐ….°ěHČŇč”BŇőĄÓ°YćÎśÉoÝňLŮ~7Ć-Ś˘Ţ>ŞLúbčž,‘P8/9oĐME#G˘ÍĚćZ Ô彼Ů+]b 5šŐo¶ýä`1xźćŕá¤Ä˝ .÷rlDőüř•/‰ń Ă%­AŚŹú?‚é»pÉ´˝}”±Ä&ĄKxŤű¤Ú’xžq®d;2€ąŽE X~Yé\'lаÎçp»úÖ(ľ{…Uť9%wÓőńţ(¶¬laCNDotSůžâýĐ=7ř('¸wŢn–4×účEëciHJ2ž„‘9ŽđŢ*??Ą‚źŰíW»…«)ęľ˝(íÝ>QŢĘ 1™Ö=Î[v„==_.“ťŔŰűĂÔe´{o¶ÔýzËÜeµf(G#Í×ĺtŠXîo¦ńĎ@b˛ă&ń–Ç.Y}QůÁČ_źÂjr~ҤYEfZ.q]’TO‡ł˘­ÎOhrL­żWĺ±:M‘fĎ5ąR´«lűójâ}śppł— kŕEąÄúŘ«@üjČ—éž\Ł|ÚU¶câ|:ŁHĂ<¸ŢČgvÜĄs‡ńt&ň‚őˇ—µ]IgBď&Ż‹‹»JčÓlV4ť¶ťUɨ3pcTň Žćp*:ńß/:1ČUŞĽoÓT¨ĺöŰfF¬-Ž‹«:9˘É?Ë;¨/řáƸŔőyîk˙Á-­Ü8¤v8k]C»çëäÄ€uĂPAyţ¨8^ëYnîÉÍĐţˇśSMH}oę{Š!™ĎÝIë*ÜńMzţŻ‘Ň7ÚüĂ#3.Ë»Ł¬l—>šoŕčd©4ę;˘¦Ôą/đŤŢp¸·1&$ô%Ęľ.ľŕâŁĎ±ŻÎ ”L™Ź÷’ąČ ęµdk)±PŠ_L¨ Xk02rٵ<$áL§Ńi\ýTëhT->Óµ˝Cľ)ĺĚĆNďßÂŞ±¦±¦¬żÜ÷ňcD#ĆX/‹SŔqʬĂG“ĽąÔţĽ:„E…řx-%´·ĺ9Ö«A“U‰DíÓ’Hź qßčÁ3şŽŠlhÓĂdýJřłű˘Ă“ĽÝ:QŐŔ!Kt%t4<&ÂQ{XůVGíÔrĚđŞÄ!?7^ٓ߭És!‡GĐŰ!2˛ČŽÝĐ×ôF—ůéŁM!k0ĄËő=Oi,’1lw*QnG9­ľ’B˛¬Ë jÝ·“čauűţyŠ› Ň=őôYT÷ŘjI{iŻńwxáMôm„btfʞ`ĐěiŹ"Ů·$䲹 ׏`<Î%Vąd]ŞĺŤÜÄ`kď%#ňoUNňéđŃ`˘Î,oí׳É^LJçăÔŁ*…Gă ßŢ´Ůęć,nn ő6lrz5Ńyŕő«=cüżeIT¸srvľPšć |~fQşÂ"xIňŇ$Ś?ő…°% 7‘¶¤č>¸§őŚĺň,Zţ×ř¤‹_@ďűŕk”]Ů‚/÷ż>#±l°©€eŞYś- ÁűşsýąĐĽa˝^ Gtň6;Ď.ă'\ׇÚlencňţ-±—ĐŐ f˙\x!#ń'G0ů3˛@®‘ď7PˇŤćľIíä›Á˘BČ\k{˛#óŢĎ|ßťř,ŰďE%ĆŘS™oËW˛ôëjdŕ śĎlćčNcßEŐÄţLöčÝkIpFüóß⍰JŚ=ôIĄďÖżšÚ­RPOłmÖbűk^lkB#ž;a]űE_‰îŔ:BÚó$ëw‚vŕWVßYlÂôy2yŕ}â±ČńŮX—^'­ŮLvß·é·’ň‡âŁy9.ľ˛y˘Ŕ µŐénű9ÚÚ|ňňůö÷ůcŤů’¤8BŽppJ(u´Ň×ZżÇ}‚{„lôŔ8$rę8Ď€qŠ„Óßšxë¬(ů EŔ§kĺŐ¤y â…ăM’Wµ1s4 mŚ9ć+W3Í–Xču äÍS÷¸âżĹżôcőd%).=¬Äę­vó¤ţ†>ĹÝܱÍíŁŃ…ă]ÍďbÔ’Y_o,» ç úJČ ĄĘ»ŘZVLi¨ŘËęijĄ~?(D’”âŽ{ť’p=îéôřhtĚ9´Ó0‘ěC®VbŃŚß6@=/ç÷ťĹ˛@ąţŚźÖ‚ă9m"u1¬mW~Ž‹;C‘rmÓÍG ĄĚ"«•DC]ŻűhŤRżtéĐÄ84×|CâTM󗉶‰Dőő›ČTć|Wš¤ô˛ęmëăĆG, d[MrjńťÔ›Ż LřĚC*Zݏײ˘zE8ëŚöŐ$*xŘŞkďí®Ż·Ü FIr“(čzľ‡Ő·Ńß6S¨;Ó;‡“Ň´¶ô 7uci3îĆKŕX° OAŤž~)iĺ)ˇžiY¸ß;FC­†ŞË^š+Ť‘ş0˝@ReV3şv”ĺ’ÖSěZ’žSsxd,ĺüpŞÍ4eťcÍśŐç=J†~01˙ÁF—¸¦îör7_ćĂRăř±6âTI×3qK;ćöĚÇLś5„¦pćŚLń6ó†AKśD’-%ĂŢ=Iýő&)ž–îÓZN¶VldrCĄ=©Ĺx´â8ÁuŘĽ.¶îdoJ&‘‰9śb˛ź0~ťÜ"íe÷;ű S-˙i:^qFÖÖóó.Z|Ř ëÉy‰‚bF×M°7ăµK%Y˝îMü˘ÓÉžWŠZ7é l\‹?H,úMŘťZÇW6«ů˝m´ŽOç×a1Úéu©4ă%#ç‡^žµ¶˝I­'„ŁW­7…›/˛ůŠZ.‘Ěýl‡ËpT|Ít<Śxĺ&‘­áÉGŐىŻ=.«\ęŐ%Í«˘Qů‰ÄŮîvą÷ňč[‡Ă±Ä˙ş‡ŻÝąľ±#ńŞç I:—ĚőłÓ Đt$`Wä››µ ›‹šMúęW®ÓC¸Ăk3dáX1Gâ' ž˛EźĎC¨sÁű€Ěq=3Ť8ÂâŹčŚÜŕÇę÷=˘–3ű 7®J3Z@ŕ +ĆRV€>3 Ă'üűţĽźÖűÁ¬ăö±xN”/KÍ2ő%ľFŤ„Uˇćz˙ÂS«Gc#â05<ä¸0 ˘„W0QîrȫжMH¤@‹ Í&Ć>uÔ#‰4ţť ůR´3ý˘Ă0ĘqbŻÉ7–6Ą›QßţÁ©˛îo‡13¬ň†Ý!G +8Śľ×Ţ&ĚŤĐ„¬˘iúŤUOSĽÇeF;ęҬĄmńĸ”Đk±Źq«Ł‰ąőCř˝“q~Ăx¶{Ymôqŕ^Vť"!ŠqD—n}©<´Á/Ď?ő5JçtěAnŻN†Ď¦<ë)WôŮ:ş©ÂšˇŰiô˘#©r‘ fÓb6A?Vbr€ ©m(űüvŤ¸vËóDkV q sö·kë¬ŘóOŘÂIUčmp ¶„Ař.[c›UKzÄ4VŮI,ýśnrj1*§"G_]ë$Vąg—óx/ąĆ_učŚçÄTPýPö­Ďúń\ş ňËđ:޵™_~-5É`–>YŠÂŰ3ŔĎä¦{"}…TŃěsUă%ľŢHç.Y»ź”%ІT ëŃDbS”¡»sVP‘ÉcD‚­˛š*f\d'$?{dŤÄLňŮĐ’C\LŹ%âő]ą·Ŕe¦5eőŰ“ŹĘO[ Ő{­ńăĄ‘Ś•{¦ŻşěW·Ž W5 BáëCŞNŠlŘ”bź+rľk¬ˇžF9Iŕ;>k7xXf[ţ¦čâRhž?=žŘ ÝŠŕ Ú2Gb^zľzJ„Ň~Rŕ Jz‡$öZ%çˇŢëŰřď*Qě•rş)ĚŞ@Ϭ= §\_ ąŃwŐé©Ó¦ĺsËśö)Y”oŽ_‡ťUÓôłĽĽÎІAu-˝‡zwŠšµ®#Kő?%×/§‹hĚ1Ř=-2ëLÂär)đ°lůOŠG˘Ăöük'»şTj÷ęëyÂptVŐWLŔ;/ŠH3kÜlDĂ4 ź¨]AÄr±Ü8,s1R왆»hdß(”%MCśóËá°Äú8¬fĄ1ňމ*rF¸Ľ”m÷ťhŇoÖ>`7‰•&!Q›SćFĎÁüZ¦de´7™ ps*Q•˛rÚGúm÷ą‚äş¶?ĆŹ]ßű^&>(g‚źCĹ˙ó©¨Z%v^Ü-‹üu­ńĺeVL•“göŮGc‚EóČĄčOś¬ů˛˘OŠ"mpŞWNÇqP.fômÉʿŸ…v«“†± DýĐĘdűl<>U,†'ϲgÚ»°żiÝEŹďö •eŹĄ‘Ń;—ÓÎ ×Ć÷5Ç*÷AťfěOîÖęn«9iŻü }Ö &‚†Nćę>?I­nĐ©‘˙DwĽŘ,č·űaňę—`ˇç ŮęćŘIČ“깪Ýëá‹Ţęz ÁRap¬`®|….ťŇş:ZýÚEĎ_áÉťO>Uđ$?«Vb˝˘°Žw’”(H)ý»Áč¨ńňű'*đ¸ßÜŐ䶸čÉâlŢëÎ ÷BÚa¤Ĺd§™ĽÎĹö{<`¬ďéÔ6ŰŇ’Z$,iߤW•®ŃÝťĹ8efq6&žgâgéu&ŰŔŻËćJ¸ąŘńÄĎŮ^éĂě©đŤľłň‹ürÇníĹbŢÇRd5b¸±läD˘đM•:LěN·ŇAĄŤ=w9 ݧńů´FcŃéáö¦žľŚ"Ŕ1ěpń]kć÷‚–yŕ?şY®>O(!@tĆ= Ö{ŻÔ/)ÖďO9"cmČř°^ćĽQ9tťşÉňŚ~lH—ä˝2Ď*ŘcŻÔřÜś;za\0 D ř˘…zăs\îÝ|7=yőÜ[ß$Ť§©6ýn«ń3*˛DP ‰Ú×_ÝjŞˇµšŻźwűhEx˝E ëT•-Łv©G|©ÓCąüĺV „Ćż˙ür€hńđőÓ2Tv tmě2Š|“˛\puÜßńL9ýiľŘýškôČ•<-Ý7ď=Ť©‹łwxŐX‹ŠüŢśÎYm† gĚĂěXů™Řľ\¦ nqMB ýfą–DC`ßký!‡®››!+Ë÷8„§šXF&uZ¶čŘż…Ô–wÉ´¦;â•)fŤĆ4ĐÓ8÷|jňI~ŘÖÎŢĺVE6t??°<íUaŔy˝·Ýá·ŢžÍY3¸©’ÜşŢÓ·]®;­ÍµË‹ßvýʬÜ'ßŢ4é 5s®ŔRxNćy©Żľ¨ţ¦Î'ŇŃžthŢGޡsś»ű#ŠE;ő»VEXÔŽ¦<ÔDt-:›ç«Sä{5‰°ŔšßÚ)ŢäÇ•O‹…/7ä=±¨§˝=ů—‹đ(TdHş¨>-"…±kö$…µ=5eµçŇÚâÜČľ¸°&Řo–US˘˙|?:Äpü|Iş|T¬çűa!řĹ›űŻ#”PČqíćůţŔ2ۇů<‘–źŮÜ5–ŽQJŇášk¬X‡ÜLDôĎWs\ ˇłI¦EÁ…Ł=™Ű=ú@fB”1ą+Ľ î»4,V—+ĺ¤y:bQS«Ř›łĘŃ{hâžÇ”řŃ< ’ÉJ‹¦?‡Z”ŻĐĽ )Âmîúą 2Zt\$1,sP­ONüBŔŐ:ŇĽo ŕŮ©~žWŇ&9cü‰›–8pŻ·sőaîĚü˝Yľť§3«D2ýŃ:ÉeżäĐg[¨ĺżiÝRĚŤ…^©r˝¤Ig^ĎYk†}›´hb2Ča`){ Ç'rË/ž”{7KL´.çÎ&y‘Hř`˘ĺĆŞ F'Ńá«QâËFî8§…ŐhÚB`˛eyíµ×Ňłâ°Ü:…-¦Jşˇ< ˘"ąÓń6źµž‚ôf÷Ż ”Ú@ĺš7—EBÜÓż'0SLUüĆ 3 ÓÚM°äúŁWEŇ"fřő>4wÍy_”a{"2©;ĄZh˛ŇUŮYź@šfQ†«6čhę›ĽŇ M$$ ň¸›Í”xNłDIU’şŻUO…浝“sę“Ôf©âóĐ_›\B5/f˘ńCĄrb'ą,Ţ .!ˢŚ$q«®GpÜ1:‰¬ŰtűÍ’¤FAŻeŞ`¤ř’;"Ů 6WŰܸşá»+©Řo1lUłfťÝ3Đ4Ý™T;VIÍ˙·ÖgOxyr40!‡ác ‚ÄuźćXűILg˙6ZË,Ošä=ęË«ů“wŮ–Ż˘„f&ăăťóŔPu´ňzЍ"nއŕžléÄŇwÚ¸Ř%‹ěýhhx儊ějx Ăr(R TŐÉôd5íńť‡@vŻ@ßćzÁYţ[pn`‹XrĘŐ G‘ý`!Î-~?ŽíŰ$o·‹ŕ„ßžaôą˛ĹiJŇĚŔU*~]ŹE©JĺĎVs´˛óiSPYeQĺaĘwç-8wW»·śgb!ó/óEú˝( Ě™»Č›ť?,'ö=‘:ŘŃŞ¤s‰}ŁI‚ĎZĄűÔ‹ßZ)él.ßÇKO\ô7ż wk ű(E/沄ăŚsbt7YüŇl˙jP…쏀VÁóßDÎFŁ›Đ Î38±I°"ö,f~ÄL}˛Ţk˘{ ”†ŮpÚíC–B ôĄ€®cĄšAĄ¤uN|źµ h!N K=`Ű#ďz˛ŽpJľłlG›‚ŃĄÄíÁShJ€8ŁúübVő«Á8űJşŰ䕸×Ä aµ?(~ś|cąe"áäô`ŽëÎňőR<%ÚÜsâo›±ç"©:ĄahĺX/ 9}†&ź&Ó‰}GÍć¤Xě&âÄ^wü˝ŕ•Y1ŹWŢŞLV1‡Më¤ ÝËď,éżÍQĚ`tV‡Č;ő:ÇŞâĎv©)ĎŁiĺ‚iž=l•M%‹eنąß˝ľ%­čŘśO.*> u˘O`ką]t_ő¶P}+dÉĂf[fť-8Ć&ĐΫ Cďń Üąt U' ľý‚Ę%É|]ßÖfj^x±)ÇźęäŔDkĘÖ‡*YÜÍÜÜFIm˘\S!ę)ŚČ92µö÷|č1ßĚš˝ŠëÁmĎ~OńB3XIxď)Ű$ń縗:ä×Ěnţ$k-MÔˇ{BU¬¶§ŻâŕßµĄłşÖy?J*ç5#5·źÓa~€o1Żýţd°5ˇB”É}bÓůërżĆ“‰­^AÝac ă}ÁĽ=»ÔŰš®™®„ičŢň2Ä.ü}€^ś^ÚŰĎĐÚ mJ7áşĚĘ Ąoé)Âi:h<,Ż8(¬UH, ¬8‚gŤĄô7pIIWăÔ@愍Ěú¬ć—RKt5Ó÷ŻËXHm]nR|ĘçűNŇ›Ş‹H­)íŐ»B™N‡ĆçĐg[Śţt$ń#ű{‡‘řó@ÂĹÄĹ€•‚7;ý 1ĹňŻ0\%đ54 …ß ¤tö fÜĹRN%KPwxďFf íňŐpĎPçůMŤĺ’)ş÷Ú¬Ý\ş†Ń7©Ńž¦ ˛qeâ5ÄâsDÎѸêϹeDě*-§Ş‡ů#׆ňp1ôB‘2}M .írŁ ¶´2v–ă•«Ţ(Ů»Í1»úЦ©NcŠg›ÉLđß3t›^îy.ęąGYH+űqQ‡xßnç>~ľľhŘ0É^LXcx™J·śąúrxCô§˝¦Ý–<ćHTđ®ŐBU=Uź{×Ć’ÍjÇŹH˙¤µ˝;ˇóé¨ ×»!ţQ;OŹHQ„JŚ™­ôYÚŢ5tvş;uň2’ĐÚ ź ×W5f¸&ˇBk‘­Ëy 3…­ÉÇ|‡ňᬠ’Só(z©¨ř H{˛îÉ&çÎáO…ç^Ţiؤ‹2˝ş‘Ä6dŚ˙ąÉ_?§ŤăŐü"$č÷Fş6ăńÍĘ(®M(–ý÷űç8´5_φö•Ôą’ ÍZžŻ-oĄ”šG·&Ë´+~'3ń©qň¦KĆ%VŮŰ/ĽdíŤńtĽŚ.˝rV˘'ýŢő–ž›Ř:˝â›č~¸űäŁes^ăő.ş|)‡”bÎyV8˛´a›pĎśÓNűá=^ăĐo5·©ß»ůŹ ±› Ă)ˇŔQ»ÝLÁ…=üă^~Żđ¸&žŽ@’|uM{•"–/Ż™ üŰ) Ç «˘j€‡DÉÎ,^2éĺËH¦†[4Љá­@ěŃÓńă;9RJ<­ő,âąî—Ýćo›u䋆pŻŇ|ăĺ»lÓ­ %¶U+o;N—¸ ĂÂŢćTöł:|<6ĽKF_ŤÉ©÷hă§`¶u-t{hÚCŠqüĆćjň-üę>$mÁZbĂ@ ’Ń6[ŐAžşy —ŢÁÄŠK{ôé¶C<Íő\8Łs.˘pJ2nŃ=0c÷„ú3YU­PjŮ—őG_c–"g[Ą8ßnŰtÚ‚˝Ă"@đŰĘ#Ą¸¤•Îw-š0ł]ÉRŰü@ő  ńyó‘BđžÁFa©î—bć˛Cv·Ź;WVßC~:đ•ăd䙿0»bĐMJ̱VÉJŮ…˘_†Ú'xúÂBÝőv{M¤ŮĆĎŤ˘g—´I:I´tžmQuŘůźi®üJ±:ÂjŽCu‘Ĺ#K['şžVadŁíź=űĺwýË“r`źÎyâłµdŰ«(•Ćę!t~âN˛"ˇH =Ý„“X‹ş’ëa{Yą…óĚ´G*ĘćĹőŽ”t>nbŕ”Ą­7nÖŇď`?t±‚ż†ëĹS9…â?–$Kc?ú(µ#Ć@˝´ŁSĽ=+׌éŤăŞWUŚiW– ?8ę±ĹSçđÖVíl‘|M;boŹŽ čNŤő˛-ă´*µxZyłňY+¬÷ĺ]‘Ö"žÁOˇÜŻŹ¬±Ą©B† ŁvŰZe*·čeÄĘ)˝K1G¸"ÚčŽW‡Łx“îüPYźiěBň9î¸{ľ_ó^Wçéq'q…đ ž4.¦Ţ¬T&Ó¬îh©_ÇÁJb©•oľţ žŻBüOö9h%H—ů0ř®ćc˝"ŚűY0qSh$˛gÄü 42YH…IôI`nž7)öł˝H_ń®ë“vwŕ5ŤĐˇâs̑ƞkÉ]÷íŮŽ>5)J8Ď­U"Bsí®ßÜSłČäbLÎo*°äŚG‡ô5Y«cyMs>÷îI‘ţmĄ4A.8Ť?‚÷5ó •Ĺö2=ŰŞ endstream endobj 253 0 obj << /Length1 1888 /Length2 21322 /Length3 0 /Length 22470 /Filter /FlateDecode >> stream xÚ´xstśűÚv’ĆNš4iĐLl۶mgb;Ťm6¶m7¶­Ć¶ŤF_şĎ{Ţł÷Yďżßš5óĚuóznüfÍCŚ/§HÍodc±±v¤¦§ˇăHI+ę[;ĐÓQ ŘXhčč`‰‰íúŽf6ÖBúŽ@«Ł)@ÖĐńĂĎŔ@GÇK Zí?”F7€4ĐQ_ÉÍH Ó˙ ČŮ88Rč;|¨Ö&fÖ@ňA[7{3SÇ?1©©˙Dúă-@Đ7´°qq°0č[$h¤i26.B3™Ť5ŔhŞoi °1(ŐĘŠÂ ŠQYe9EršŹŔŠN¶¶6ö˙ĂEPQIY” Ä/Ł$ ŞPD••ţ|*­?ř›Pd”>ôň|ţq—VâWR—¦§ýsz€3ĐŢÁěOÚ˙âFňÁ đj®Ćö6V%™::ÚrĐŇş¸¸Đ898ŇŘŘ›ĐŘZţĹOÉÔĚŕbcoř¸Ú-ĆÉÚčŁśŽ¦ŔřÓ€”™!ĐÚřÇIÄć_J«ŹR~8}Č˙—ŘG!˙Ä´ü—9ŔüGS}‡ż|Ąää¤VúfÖŽ@k}kĂCG}G'€Ţ_˛Ź7Đô_A'{ű?9¤˙­˛˙ß4˙¦.`óqgZ–îžú.˙Ý1}k'‡ď«Í?oŰĐĆÚÁĚÁŃá_c3Kŕözffý—Lš_F\DXQ‰Zęc𬩥m>ŞcMăčęř—őźxüBR6:=;€îcH…­Ťm¬¬>X;Ŕţ)źŮGťměÝh˙9ÔÖ6.Öî˙%46ł62ţSs#'[Zek3;' ¸Đ˙~`˙#3:č@;ĐŐĐ”öO˘żćäŹţŹřŁžî¶6¶c}K §™1đăëî ď 8Ú;=Ý˙®ř'‚Ąg™:~ŚřÇšŔţ]ÜÚŘŔţ/ń“«ţ§ůd­(ůÇ~ŮX[şڀð´26ŽŁ@ö˙gĂţ+—“ĄĄŚľěőüo#}+3K·ý—…*đQ˛˙Ă×ĚAÄĚh$gćhhúŻšţK.î¨˙1đüÖ&–ŔŹ~ü%RţłC–Ăúqŕý9ŻÔôL,˙ĄűCC k €Ťń/đŁ˙E÷ŁěČhUd54(˙9+Ů[Ú™Y›Yúööún°tŔŔĚ p§˙b# ë_ Ą±¶qüpŘ:9zŚměa˙t‘…@Ë˙GôbgĐę˙±h ţŘ´†˙‹?t†6–·öo =€Öčo@ üdĐšţ ~ä5űügů7ř‘Ëę?ţ#ňßŃD¶ůdĐÚţ ~$˛˙üHäđ7Č uüüHäňČđŮí/řĎFČý9}ţZ/ş˙tćŽĺż°˘Ł˝ŤPŐĚčă'éo&ŇúŽöf®št»A˙!˙xýű›ö?˙g­˙ć- `ăęNÍÄB fřč =+ ýcF&Ďřţë„ük/?FčßřĎń]†°K 6†śćIŤA%^ÂySĄÄě4§ĺ_xÔ$bÁ—R§Ú°1…˛· €ĽůľÍ>i$ů6RbÚ^ ľÖ…jÄč–oë?ă+&oŤäůvô˝¤˝°…ůGłTh”ýҤ}J;ČŹ$˛rŐ‹fŇZb[ľ”GŹŮŰ:ź"&ŢQ® ´J[Vs \ ćč›Đě-Q]‘±Ú±§ÚAߟТ#ô{ř—(főrľŚJ@Úvw~ŢŤ(ŕýM\7łýŐ¶űÂbŽż+łřäqć  qÁQJ%Ż0ˇN‡ĚYy$™kŇ+ű>$cžű·ťTǦÉÖTKÂsÉôeâÄhÓz˛ńw5h~‰ç’źNZŢ2Ö•K¦Ň#žŐc$a5±2ŽHBwlW‡üŔ,°Đ@ŕ'Ţç¶ŕ~;ŢÝgV6#69+¸F ®ć-X×DÍ@rZďáĐáNĘ Ńf»€Ýbä÷hg˙|'ó’ţČs’ÝŻŢ„z*oÇÉ$w2hbŘB6¸Ţ¦(xż#cYËđ˘bÔ8“;«´ ÉŐÇúř§ć„m«‘ß^»–ó\-uŘa:ÎöĂç•EMyÂUÍ!\Š›OúiŃđ(/ż}üÓ —pö+äôyP[˛QÔŚčUnNîš‚>ÉăšŰ#Ă-ÁŐ›bvĐ„ĺ((üÉÔ\~ë:e}X6•x “…Â7‹ś7ÝŞ›JäďRŰ ´f®ÝqE…U9CĂ0pŃŇh;lŐ´ŔDűvÄpĚw›Ł‹ň&‡ e'%˘—xřš2/…Őä"ˇ‚%ÇÝeiţňfA?CĚƬô:Pĺ ˘ő¸†b h˘”ť@pđŐ=ěňHöç|¤ő3!˝ť§DT´ÍUg‚[ÍŤ¬2ý#I0ů$8c8cčńËë"włÚw ľO×}IµËwŽĂĚ?6ŁîŚ´%—ý—í¸9űKŕ'ÜT©ű`«]·ÉnBôŻűń´î Ňű°Ţ]@@đ†Řx5©µmÚľý€Y*Ě ŻKϦ¨U§iýT´â¦Áů:fâš°8ţbâ}Óo©bpľýů4ČĎc ns±©]Čđˇ@`¸•‹ŻCÔüŮÔ_í*ˇ}ü¤Ě΀ę0T’ß2’čýVG]®k®ßl”ě~`Ő™2tt‡í«buLFn$µu©z;2eé[U ¶X5 ·˝4$e9aO™đ®™ďź…µ¬ţăRv‚ľęĆÓyôSz)LJq˘ĐM&/mŐ cV¬Ţ09޵˝·š4É˝^Ý÷bb7–”ÚĽ‹2×ÂŢ öć©ÖH9´d]“ěa¨Ć±ú‚ď]% DľŘ TA;ĆFt»o˝é˘B†>–ű¤ q WEsoq—·ŮÂűXK˛ăV¬ ">’×8Z*Ť*źó9ăŠ!OhcĘŕv…ÁŮ7+ëŮ2úNGuU&ĆźÖ"t5?ŮÔE4­—6‰?‚˝Ť¨-ě¤"{M„ńtxév/;h]fvЏN–MÎ>wú«Î­BölĐX˛Q=*á=l –zącŤ’9UaNż‚Ś8w×!'Űĺ–p–y0GŤXŃGŮ‚1io\–Gč$u§oî¤ rRičŤ đ)ÂĘšLľ}’Ăť4{Y´UѰSĘçVs'ĺc&đkExö $…oîšk”0IĘLÚâĘ.-űjĆ'dér ±´$Düä °|Íy3şš3žLôuGy…‹=Á&+Vş…Ę?~ZuA‰ĚJ‹Š:Ęś¨Nc´%aů6ţNëuľÖNšĎ3I¤Ů+_FíŹč~*Řc#' °ßŮg¬o JF†Fé SH) ŕk_ŔžÇTCŕő::xt IŕĐ[?MĐkć!ŁžSŞĽó—?éí'M2AŁţLkp‚o‹+÷i(pĎĺĆcÓb#÷fM8¸zŇŚ`Ř|aqŞ‚ö¶ČĘ «"Éöłßň,YW¨yĎ)ć-U˝hRĐ—­_Ü™ř1‘IMXqŃ . žŁ }#ń7 ÝXřM˛÷ţW:ĄňRŽŁŤd<ůĺĺAp*ŽĆDęQôő­E|#s¶‹-żśˇ?[í ŕě×$pÄ @‹öóR×Řčŕ ëĺwéŻ1É ,^ßkýZ1uצ|9„źb`.ŃYk”ÜA<íĐŹŚÉKý÷Ʀ|óe•ÓŮ áë‹FÍű¬9ŁeAvQ‘a{ÚëÔ°¨"L¤îL”ÂR–› ŕ§ôŕă\OCq{F˛ÚWÎnČx»©éÁR†&Ştµ/LˇÝpÝGL!«=hŹîI_•ăc °Őˇ6®2Ą¸Ü öcŘLĘDˇZIżdç(ăO¶Ý´6´›p®BU=[GÁnŹS5ßÍůGęTŐőµÔú ®Ď‰Íp#ňe@lšÚŢŠGßđ FÖzş1f¬Ý+†ýp$j-Đ)×Ę9 ‚„§.šŻküzťđO–“ˇ(S“µ¦tŢRÓýtź‹q"Ő‡v‘sÖTQÜ6‘Dö~Ś –MŇśΩ'1řCŘ Ç]‹ a‹§SPŤůá_gˇĹ}ZµţşëůŽEć™'Ó.Ńď­ÜN4™żh1}°¨‘<i×:â8+P$Mi%ÉsµĚNosçţ=ďwŁjů…Ę»8aut‘ÔPhéőé-×ra&Nx>×˙WîŕH!<Ç—Ě'°[JšpVoÝúříđŤ9-Ö7¶˘*ź#¦^Ł”hÇ:Zę=A‘:#¶źŇ`w&2pc<<ŞDBě2"l¦˙mÝDçĹ rmĺ]ĎŻŰŐöAWÔíŕ% § bž±lřk—¨Ęrg°ď~žëw“˝HHWíV•ČĂřőˇVŕűرś–ü^HoŰ"rÉ8RÄKĎZĐSŔRšó‚-„$NpÓWŮ€Cvą& ,úUÇôw­Ě‡peŘä.sĚŮUÓ-fúci%ľAYzDQŘŢĆbx6őOőüp±©Č“dKµjT÷˝Á {Vču%řŚ™äŃu5'é¬ÖÁu"c`Č«›:ô•€9n­˘Ě nqÇłZčŕŐKŰđÔÉ7UE$Qk…Ůđ§–ÔŮ‘~NŐđŠ+E±ÉÓý]–=1Uôŕ_šß°[Ł~é?/éŚöˇÁ;pŹúŐeć9ç۬I%©Q küŚ çtűŚÝ*pţSë˸ŷxŘş#ěµ’Ą0ÖíĺŻ8ÍĆ Ě­¨"c×l7ńŹíö¤i˝Ő3‘˝.^]ĂońýÍI˘Íş¸Č^Ţ{o\űCuŐĺN•A"®’j›ëˇ{{ůl-0˘–r2ŹBÝĺŻt;eËeŐţ÷—µÖaČ7ş1zh2ľäţ]¸ÔăŮ 3fjL!ęf±áx‚·MM©ŤCžx+ęĹlJĆĺIwŹ·,¸ĄĆ¦ćˇ;}Ý;ţ×w ë"Ą=MQ_\7˛rÎŹ^C&Ý ¤Ľ*{zq­T÷qÖŻ?H$ól¬>â6:V‘´3†>–Ź_­î,ˇ_ľSřmýĹ8kź8±…âo#k@ŰC˘ň[ó˝–îW•y§á`3D[EGŘ_T«éiŕN·>ŤřD>ÍTHÇjŹbV„ď@Qrăá§ě’ô˛bĎ5S=®«žÂĽľ,lŔ‘ v5L©k–'Ű–Ż!ľ]Kţ`5_ň HhžG ż@&ŔeŐq–˘ë5îŔţŠlŐz¸jó˘éŠĹ•ş¤ Xé!€$I8éa üt}Í‘»ŐoŃqýŁřp˙;€&Ă Ö€±–°ů=źZţ§1Ăeűuε PÍS#Čţ@6Í•Łć­tÓnjĽDŮCŽÖQn \"rqTuŚ˘Ô GČ7« G*XÂvřÁiĄ|¬â$jďŤzĐXRÄťźś/řdtť@QíökbŹ©kPn‹ĆĆn±Ce'É!d U#8J}Ú™áÄűŇr \t vá»Đ°ßt4XvŘ_ŮS`aŃŇŕ˝˝5?ŠŰC̵«Ą­ÚŢ—ď€Č/,Ŕ¦ `†Bš”’dŰ=á:7Ű`ťaöM É]§_řłű¦ćnłŔúŮžCЉeĺnlCłHę6n 6âÂ&0µöJq|hÇß‚Ń$,z±8şsmÔű¬±)–ö·ĺÄbV?M¸e“Ţ5˝nĽŠ sBńŘĘűüÜ,ő‹ĺĹś˝M[„ÍŚé6ĹHŃî÷ź¨rŁkşÚ•ËY¨#!DĆvîÔ€·pÓ_0#“ćľ–÷ôˇ6tř×D—Í’(ŐNŚĆ| }eőJlîŞáŐŐ— $ô§LÍ„ś^)üô|’GI*µŃ@EPQżB7űąÝ×Ă—gđ<ä3‰aNŤĽ2A«‘đ“ľ-3lWDŰďL9đÚ׏lÇ‘¬,Ş}¨°ô:ËŤÍ;}‘•° o"›DBžÇ5‡Z]ݱ“$¦†«\ćçů‡¨)xJŕ4‹şÜ:©“ťŔ†9٬ףé|"Tm ćńÉ@űŢąíKB¸»‰í­$ňwŻŃv…Ŕ–CćŐň6.úó]> )¤ $ŹŃx邟h›BŠâîNśRź.ˇDM3˘äó2Óöź“/ü+Kł.˝ôY…ľ &˘çřČgwuŁi`@ľiXäÄۧĚ7˛”ÔnPM6G®Îć§ú‡XŐęAęp Xżű@ •'ĹâáôűJąŘböě=žŢ¦Ś\wFí#Fß8µ5qç\syÉą÷^Žä•ŃHËŻńä‹®Ú73p˘7F§ń̵2Éś[ôţřţŽR9`w,§¸Uß –}ŞQ ‘U~¦ŹFľĽÂ.łÜs˘›nłňĽŐ¨ęĚÄ­!é#ń 7Ă„Ł ĘÁ®°ÝČ‘VH˘ü,%ř&šÉă]eM ĄăÔŢrŰń´ű Öđxm‘ ĎÇ2 Őđ”?mןî6tzç6Š ŢËń¬±żëfÔ†ńń¤­&Á ť@CěąţĎĚߌҦţíű'«°3%uT»ňnźx˝âUv†š MŽ(OŰą nŃp. ŘVs* îŢď/ŹŁs×´µĎ÷Őóľr-ăö|čŮDş.Úéý±&o6ĺd¶WV PÉ©Rrˇčg¨Î /PąćÁ”oµ˛˛Şąţ\;:?öbK™\e˘eúbŇŞÁí<5=7ťpN´ď1# ¨Ţ¦|{îřK^ď¨&ŞÄ,ÎöjÁµí î}Čě— ”­&Î[Xr~5(Ő„i}†9L4íŞâ×MTŁę iaŁĐ‰'Ş1ę=pů†t.NĹ—d,7ŃĘÚĂ5 ^sˇîŢóEáM Ň·ył¬ŞYĹ÷¦TȉwŁÍ‰ŢĄĐ4=ß.55s/„Ę' Źë†7żÓ˘”® ¶ľ±7ţ|ÔuîގËKď0›iĽ‰9Fgę3ŐQs”«ő´‘ďîC¦Ł\Q醩/7[:«BŹ:E“¸Ż“AlÓ…ËřJr»Ţšß^‚ćE9xÄďox$}Ż'9±Ľ‚öܢäAcآ HÎP<‘ĐčŃ€V«Ačś$Ey?~—0^¨§Ms¦}ŚŃ,Ĺ6Źp¶żS¦ö|[Gđ6ˇu=BÖËţuâ6Ľ|Uąş@îâňž´B1ŕám0äÍ[qő)·Đ“sq“—?B¨8ˇĎő—á[˝éË÷ܵŰHŇĹXŁĘĹö+‡ĆŤË{ëžćĄŠđßfŰ».I­ž¸ńý+ 6Ý1đČň94ŮU†sÚ>7ÝéfńŚÂeî˸ýťĽĆ”<8¸ÄŮ&äMíňŘ•bţ‚Ă„­Ó, °’*hřÇšź>C%¸Đ 7‚ڞkd#ő?ޤ$¦CúňŮŤňQ=ŘßVƇd†ńŚ3zŕ O”ËVŁV…é*É–Q$`ÜZśűŔŠ JBiÓUs÷ýÄĹÁc}ęÂěEôÖň·Ň¦dľSĂÔ5Ë·Ň'Çf«ĐĚzźĺ$ň–g9_»WĆq‚ß. ďůĹÉŰř”Ł(ŠÂsŚg„Ő?‹ř%łÍÚ~OG‚FÇoúmuŠ}ĺ^éD¨·Ĺµ†Qó‚JiŢH”o¨-iBěăžWXW™ÄÖR±ç9CĎ—g3˝ĺ5mUwťű›bö#měGg…Üžî“;ě8Ń/¸ŰŁ$[lăăţÖ$K3ŮNËRŃWşąJ¶:n7łš:Ţ;5 ÇŃ‹ Ňßel DŔóÍLÔ>1r|± ;r7vs©bäBąX퉨˝–ô-[1ěun†SĎĄ°HÜtuć›Ŕ$’üúażërź&®mçpH%Ým#Ôä ČâˬÍŮŁ˛ŻAY&î^áÉXĄ'rLËăÇűCS]ŁUß:C¸g–ĺé XDd2ĺâüĆQ čŤ+V´jTÍě%I÷ż qžg'ř&WÂnn*.‹ł¨µEw‚K‹ˇz3´Ď t|1Ţg›äümE„ÚŮŕĘ]×uż€ČÔˇ. üe®OĐôu—¶O[n˝ĺśčúx¨WŞíó©ÖÂe~?łm¤ÄCv„=Q& RtÖALY‘˝ř‚ um ‹Đ9 V?QÉöaăűó1ÁšĘ‘Ł‘_}O‡řřĽĄ9ăV-O» —uř±×É6˙Áŕň7~^şŚ6# @ŹU´n]˙Ŕ-A› m5G#F^5UW‘Š'ÇŇŇJϦlî\ÍVĺôă^÷ş–â¬A•ěČÎD.Ę.–ë-ŢÔ]“Í ňËýň2;ś˙µ3§etǬĐ(Ýť˛ˇq(^kOÁgOóµ_•ş~"[ ĎXĽ]#TÄűbŐ”‡%Nďbń^h_~?% WPňM n<ę t®@­ĽѸăL!„uZhŤňÎă%kŔě Čwôäbç3ĚFťĹI€ *Á“ŇltűNŰLn6ŚĹLCZ»1*–ż“ť—ĆÂVŻoţ_Ý;Â7¸,„F$’÷ú«Ç«@¤×·¨Ó&k~—IědSVC}±+źčy ô8®2Řhîń1N»cÇ †_t“0Ciř_§Rąl\1¨îVw6ńđ+ôpáĘrě`ľÜ®&ĄđčeeÉÄ?/X{|S© “ď!ź…ůÂn˘ű’Ž,A…żŠÄŮ\׺2°ŤŤŃ‹lŢ2LĚĺ…d‰w”(^gOĘeŁMňuAąW‘÷Ęc°ŘýŞůâדvÁ‡OujN™/z3±ŻA|úYÎHŽŮăhăÎgPü`ľĺś°ÂĘĽÖ–XQSŰ/ax®u±‚{d?}řń\J\ű–‰sĆN+äҡ<Ô|ôµb q”~ÍŘ퓣 !ňG•Ę5WYYWÄvIŞxŢ€Dx€śib¬3gäű"®):Ś‹Bf`"ĺľF6Ö~GŇŔZ®ůUTÄ~µqä˘Ű’#®ˇJú•ĘŽ‘ňYÜ@g™›kw×_Ř1™çSů˝ ­ŰJ@l펱rO­–·5ç^Ńşź:tŢťÖ)ÉžÍ0Đ@$‘™|p»°'¨ ŁĚkŃVómŔ ˇ¤°±®ąŃ”`čH‚ΔLěłRňÄĐţ“¬Ý–ŤGËD|(ÍŚ±8XÝ®€ŐUm“-ŕĄ'Ú&ýĽ›-—˘@ÓL»źü«ąŰ•ú$\˧ă]PĺĆşţjÝZ6Gš'°:͉L€ľE„ ć·sK_m•ěÝsTk«I›b_>% ·Oę®ŇÚ<Éf~łáîѶî1ÝëŰ—jŃMŹÇ+Ý6TOBTm Ɇş÷[ZU¤˘…•-{"Ř\}˝pTĚ•ă|aű­€¤×†Ę¬Ĺf?CëňyÖ·e9o ź°ŘČş´*ą—:M<3ŕ\ôÍtä 9ŮU7Oo%a ĎMřĄ÷r.ßř,8‹Ő>ďTľ¦řËŹ—‰ÓĚ73­6§őÔ]Ő 8ĺ퇰¨,Y+\«| ŮóĽ”ĚĹ|÷ä ]S4Ű 's;("ÖŃfÚQd>ł8Ş}ţŇpâÎ )UľŞ¬ýĂtĄĆ‰*CÝĹÂëoç|^R¶FKÓełšßm±ąĄGźŚµ¤AşA~Č1 źç-&Á¬ kÉśö‡őŮ9‘ží"ĹőrzÍ˙¶hLů®ťBˇŚIxéă6Ş ż=QExĽ–ŐŞĽäd)Łaz·a÷˘—…RĄ¤pÂŤ°ňK1 ćëŃţ’++ł…$ů\ő˝GX …wZŻ/XçÔn°ÝÜ 2ŤÜékšNSúýćĚëń«ŘV˘,¤™ܤőŁŹő'„×uŻH)b˙¤q«"Q%­ýć• †ü"ŹSšBHá3p1[hý+âŠn#ˇ{^“K± F"™‰[>ݧV‡.ź–€b©´>|ůcý;¶@Żs#”źŐy 1ärâ•= 0›™'!äĂ’Âč?ča&ąh(XMWG´˛,úÂ$˝·řؤä?µbÎGďQ’X<#|* )XŽ{+CÇŔ¨KîqbŔť‚Bf[ÝŇѦĐÜ9‡+cż(ÂBXÝ?Đ Á5µń'÷.MUa.™W=9f « K’”'Ď·ýn.Ëx˘PÁń q‹¦Ř÷ą n•yźĂ†Á·»ę&&©’.4ĺRˇ6âţSTÝŠŘQ;î /ĎŞnłhÖđo"?ó˛c¬üç1',OĂL†~łÓ+Të!Ť#şgĎó ©ŽÝUBC+˙Çocd+Ę©4ⶆ”ł7Ł 4ÚNeއt?Ň/2ź´úĹąÓÄűŕjMH*LđډéE4Ś<ÉŽřŹâ@˝¤´tÁ¶Ç@2ZěŐ.G;»¸†Ü§ 8Ŕ<ľ¤ţ¸îVü ĚÖś o:˛AśKînፌ“Täâ1±ÝŘ’źĆä´n®‹~^{š_x”ö:Š#µ\SČŮeó«Z-/ţ{Vô@Ęś:”…ÝÓń[Óť ‚8ŚsÁ™ÄJk¶f{JĄŇ¶úIVď>˘†łW‰K5][C$7żµÎ'–Ąţ8ƦR‘›Ľç4?şűůôCĆH…Ňl ľöÝÇČ)Ę´8áeŻ“@ÜęPíŞTbá×AÉC’-×ŕW 1JŕńÚ^ÓakFŮEŧvşúÜ3]{hnkŞ?.¨iqsę]Ą0ʉŘĆJ]•™o©4·mĎpzőTäVBW‚ßpzýş›Úśŕ00ő÷WŻŚ·LhŽ~ŇÇ STłxf;¶w2ązĐdi{T­AűĄ8ußÍäbďv”RYÍgI5Čăµěô…c '‹§ŢŹhň”šŠ&oËŠź‹†Č;S·ÍŻ”ńĹbc˛+Gú„˘˙jQ ŚqŐbaEćvuŕĚmź‚4:%ŹŚ(ą¦|c˘ăžŮ‡1˛PÇXߥŰt»5 5ő´•ÍăG\4$˘ řtM"猊˘HçČ7µÝ·ť‹s“Sťéfđ›˝mÝmf±ŹőÇŔ•ۢňbY–Š))ĄŚäŘÓ®!ź˛Âs_ń{%‚ş÷äo‚`STĆjˇfŘqW±·(úyQç§÷:<ćTşuŤc¨ÂS*` ¨wOc€ 4+\:ĆI«Ębš°ęŕWŞqüb¶]©­˛Çhę^\,§S46ĚŰĹdQÍiyD ÔŹYYŃßÝ,dĆŹ LDiĂŽÇ•‰äŐ¤·'JÎ=×ęű‡Uý˝ěßx~Rs]˶ Ô\Ý9Í˙|ý«-B}V ô Q—gđÜČ7ź«GcÁÚ8Ž7p9Đ?G„ŻöŞHŹőcő•łcZ$ó”,×D–ŕMýd*”ßő0˛’anŘšJ{GKáóuĹfEŘ_@ŽĂď}†íQS(kď@®ýŞműÂÜiźůűR¨"ňŕ÷Ŕ$¨Ô+uŃË‡Ż§ôîĘrvr‹ŃLśZj—I7k‚¬—JQ‚4#™QGâ—ĺ›‘Ł´1¤«\»2?AĆ#ÜŁ]Ëd°#>™b™D=H5wrëZ°żÔĽťOĚü,+ZBy|Î%ov’ú–ś@ć5’q-Ţř• ś0g®©Öm'^*R[~[ąHÝ4NŃĆ´)›ś4µWb2»¦!ďúÚéžĆ<1ZJußôF]bö*XoÝ!:5›"č‚pţ:G±©ł¨ă¦f<č¶B”!ž u“±ZGŮëŔ8l_?Ť'âG™+gßĆĽ‚´Üë€‘Ł ć ĘŰx”«ç.ěsnűËîö,ťĆř´ű¨®üŽéٸe!#ńŕęTŻŹ×Sŕ«cjB驼if/q1aq„—ž‘kÂÄxâmu ŔtzŔ“G¨N"ČŘCf8[,ňk0Ô}E0Š ť Č}é™ĹËr]‹B23)˙°‰˛m>ţç!ž_¤ ť]0ϱÚCöüĎövjlą¶ŃëŚÍءú—ÜňQŤ9¶ź…BÉxoZćőŔzxĹGĺjg°ŕ4wA“óĂ|QjŮá(wľß Ď^ŢAÁ ±ę$@Ďř›ţňŕvdwÜ7$8ŹńÄá˝-Tˇˇčy,4ńž”–kOsőc.…m:Ęßšď}[şv ç…:LÂɵ`çHVÉTůÎXrŤ’<°x4íئŁ/ĆĘaëH;s)Ża°‚¨•ŢŢńm«ë·±Ť9żţľ:oćUhĹţŤ¦˝ŽÄ¨Î<Ţ X3›–V/bď{·R2­đ§ť$ăn:ĎÍ Ě/»Ě7¨HN:怟»#s8ź'é]«2;‘cât!6đĚë’ĐG6ŰQ€7 •fěšT·ŹÇ—âÄr|[OV.!‘]ŰňO_‰• . >˙ŕĹ‘Ż˘*ĘKÝť±”ÓĂEż%@ćIÖÇ #ľ‚°ßëDUpzemŚ)´Jč$š¤¶˝e[ĄUÇ“¸Dp;Á8›/w.Yë2Ş »–aDgáC5śA<§ALĽî‡ĽU`LŢ4ď|ĆEą4s‰î'ČĄQN’Q]S Ůá¦âË łäońqëą ýÝx©׏ĂŃ »h ş°%›—h"Â1 iČ—ź)Q qţ:Ím“Ç{4ŞTą5Ś[ÚŞCřλŠň”ZŐcç3 ľeWýóYÎsqŻˇŰ´Ľgˇ˛Ď˙>ž´$xâĉOů黋…~S`ŇLŃ…T·•ęü*ö–/ě^EČHßÄćơÓHQ÷3-Sȱ_°)˝ú*Hakw»e†CNp{ĄáĎ鯀ącâąź)á;MHDٍmLăL˝Äź'P› ’7÷˛8ĺűśÉ\“Z,v*ă Żä](q’íú zęo~»­8ŚsVÝ$ˇ0„ŃÖţ„&G¤˛ň)¬wű†‚5Č𤠣(’P™ĘŠFÁ6ˇ±ŻAĺęGHo?çá•ĺ°;6ŹĄúË”©ŔÍśđ')—ü™YýqaŔŹ#úhĚcĘ%“;©“Ú Ç ¨őłu Î[ÎÎ…Ť@’ Üó9’ÖÓ“üClŤ´˙ŐF‚jb;ú"S?łł.F LŢËóÝ™xô>]ŰąGSĘRIi¸µK 9—ą;k]f\kAľß\[Ŕ°wá+ő^mÜ’ç'ćζURU6XsvfQÚ„˘Ńxň E–ř¶D58艗±;™Ŕ‚†¦´˙4Ö˙ń©ŚÝÇ;ě®˝ßË*ö’ŤĎ˝Â÷[2wĂ}oýkŚËĚf\y LëzµĄÝÍŞB´9˝ç—„÷×/*ř§a5J*vŘ$/fĄźÎč˘ÉryŠ6Ľeög¬,˝łDë± ‡Ę©#‹L6îKëS?Ő$.˘˙Ź'×OÁUŠEŃd#6Cę­ÍBźś•ýrZíCľÚÖߢŔťĽŠ›ĹS8”ĘSşÂOÝfjËC|'"Ľ2'ewÁč˘PoËJĘ®*ŇA‘GD7¤¤,÷ ˇű0áÓ)mÜÚřß«ň×€z%Žaýäo€ÉÂp"ô^ö´AC/ę:tH¨,`c ˘`fFo¨u‘ehněb¬čăl9v|ĺĚq˛IM`CżűMÓ˘UĎőpăŃF ;GŤĂ^žčv– X⏌łpZąpĂf<«mĆ—÷,˙]Ě@Č#®°˙ŕľ®×Hka!ý|łíŞţě€9GőFQdń«xż_7ĹÁ[]éâL(·Ą¤wČÔćÎW}E˙&‚5˙ĺ•Z•ýěi´×)ž_vˇî!íÄAęˇnŚ)QYW-:\Ži¶|]߸dś±0ŠëhĂ†ŚŤc1GBŇKÚŽČ“łúÎĚ­ť“‡Pť`pHfxßZv<–gUîŰ ŹÎfĚŔzHnű‚ŘĹP9“űJď‹v^ńčmXN×;f7ÝXÜúšČÇŚ'íąî˙kIRçŽ}|%“ŕÖĘÄcłl€?<´ęŢ`|^ 1©Uň]HY óÝ8÷µd¦+kĺP"aĐÄ&ŮŐ§Čş¶ż–…Ě9róÇ?ÖůŇÂą ©ř°Ň4çI'Q|.Ëó®]hBE.ŻĽ˙JłE›xb,m˛Äßăe]îš±Ë}Úđ#NdĂę“W`/a=Ś6Yt´Ëj×"isŕW’ܡ_¶˝D`ܧŮwH(3ó · uAë 8ĺńĂ /ë4`Ř żš§`ňÇ/N‰ýX`\ĽO(Öc´·g?şß;ŚţĐCżŹµR‰ŻË/>G’âćh‹Bŕ@¦3±Í®Š«ćSśÎ’.y4ŮÚgpaÍç ř>xŤu&xŃ”zúĹŠmâBRí:ÖĂÇ~¨Î`M¸yŇ’_ÜČ4¨¬,ě¸Ç¶<ęk˙@‘…Áś0M-öEWÔXŮ­m÷ň;v}>˙mł[¤–Ŕń:ţ‘COt˝MĆ(ü†ÁbÓď7ŢŔN2Pz<Ô7é 뇭(Pp‘Ľ*ĺp˘Ă© yŰě‹ÁiŠ­ †TÁDUm¦‡DąmËoÓH×Ý6Şç1ȶŮD éd4×YŘŁłBžv’ÇßF ­ŔĹđŔoę”*"Ąu^±‚ą6* éҰĺv›O#ŹC‡wC1ý5-Ý&ąâŞ5Cn0¤ĹŻ'®źŔZĹúźjŹĐK N˛81ˇC‰qĐŹ!‚qC‘Îő“ĆM®kOÍNą[ËPäĎ:¸~ši:ÜI<ťwY~Żâ@ Ő8k­, KŁř´=łPÓ]zď:˘Ă¨'ĹÁ9|N%$š™^łcCxročä PżŢO?á\ń;CnM•8ń­ćˇŽaó)ęP±€u˝ĹÝ›ĎwH;]ݽМ=+Ů1áWśh™URK`'XhÇ[˛M‘~ Ě´Ęĺ.†÷Ľ‘Dĉ1úÍ>WÚ/ůş¶äŇ „ÍwţU9vç×’µ©/d »nŻÓůŮÎnÜn˝Ň·Aůş*冮Ş+ż(Ş"äę6,Ľ| ]J´\™EQž°Tč5aéóQ°– ϦeIĺ]t VOŇýÉďĎÍVcô¨ňÝŻüf›dŽď ‡Ăř0¶”G•ŞHLXKF’`ËAW=tX9ĹŰŁk52ł…÷(âŃß>y]!Żd“«Ďć^őwż˘ň«żŘ»ż+I+`«!é2=ٶí)o'ëo§ŽĐ`',´’?‰ŔO%ŕ+ €i ×í.kä˘&ęĎO۲ŽťÎI`¸C=ę 2Ç“M‡@züŢ,cČáŕîű˝ą##¦E˙L®°gŃ8ËÔâżLhľjÂŘ;“w¦KÖĄđkĚăů*@î[T@'§ÜZ„U›k’°‡1ôFđ:ş8š^”¤ açOŢÄVV-JŮęŮ î[!žz„‘öČDŞb‹Ű;tŰoň`M·<˛·ŽžźM+É•zŃ–°2”:~ŞŁoé5ž‹ˇI&ÝÓ–ÓŇŕ‘_ŐçŰTľOv|1ôŘ3$ܤŮ:µŔŃÜQ1­Î“LŃQ{z;QŔ Ô”*yKaźN˛RĄ8žÁE·Ď>ŤnV´6t$Ăy°btôYż#ç µ@.\¶Ë1•µÚ_kÚ‘‚¸÷‡ł•JHČóóĚzŻć´:…¶ě¬ĺejqŔÉQc¦}ÂŤ¨(+u0Ă jŢU6N ¸NEMď =âl¤śÜ˝îŕ%ĘďŠô=—’ŘŽęQPyóĽˇßo®”2>Ö tČť«×»"Í~ôĂgdć®iR_mhé~,ű‡v5-AkZ[9MdÇTďŮ ˙=µ?.Yűy­ž$]Ăä˘` ąŤűF-JLxL ¸)·ˇÁçxNŔŕ;¦ĘާăA%"ąÉ.Ěe‰ZĆ ń;*U®ô5aţ÷2oF·:ďô°Ů=ćĘž¦?kbŞsá‚9Íw|Qě8Ýži‰g˘k'`łžĺ†ŔÎţBCÓ<énŕ03µĚCĘ<ś°×MčeĹă\ę;źËěţ9]N'ţ”Ľ/;ńTv{NÖí+‰:­¶ä„ Űł7bă·ß/:TĆÄŃéjH…žCE·l;ó“9ÝĘťkżň[;mRźWε~íĐ ˇ¦i+Ž˝‡˛ÇŐk´ďZdárµ »6RN$Ď»CĚŐŞó śâ]ŽÔĆ8‘9·&†7—âÍöďŤHhňǵ§÷=u/(2,´|ˇŚr¸Äq¤DAŢČkU¸°ăţŔs+Ć࢖˘ŰO˛OňTT@ŮďÂwÁFŇâą đňůŤ'á0łĺD/IŢJë­ M1Ě®Ĺ\(™Ű·YÇźé­f~ß-”‚!ŠcP-‡DnrD ô\ěůAlŔg÷ö­9Ŕ¸•¦ˇš]qN^´ŮÂ߬Şé† »˛é ćNĚ›`ąl91ß źÝĚŢOVܨňb ęGDŐfc[ް€ůţNđŠśbČ{„7„Ě1°qlňý6ź şocf*FĽËË( -ΡA<“ŽĆÉlĹiOžśç‡.‰d¦Ă.Yi4÷ěe›PuĘF”7ë’'AU¶ ^łś_ŇťřwŢež¸4…k(6BŁšŠCzAV=VÔĆÝľŁ˘†ł\ý UÂĘ5'bGâ_Äż;oÇňćĄhJ ź÷FĐG;h^ÜÔŞ\1:#łÇőyUf±ę|[ŹE‚tÖž™, {Á˙őÝL_µś\xd´˛ýZ`~d›1›¸=ţă5ÚýžlĎą+¸†1ĚcĘ«a˝ýşű=s˝r'z¤îŕí$ÄÉä;˘ŕ˘ÉćË×ÂýgŢ«Ň!—†9&üŘ„U/skÎLLd;äo2{”Lşeęëâö„şÇîü̡/ĚÂDŰýßěаsk‡v6P7ʅĉžő v¨~x EX78› ďÎ'zőŮ(y`7¬*(Ť„Śčńă  ˙t KSË1MĚ  iŮąĺŢi&†{ťłÚ‘€N«… źrŚšÖĘbN1ÝČV˛›µ<$ˇĚ/W}[ѨDVŽLËŠ E˝ˇPĂ;ůݧP`‘,«lý# îÁ…5ť ¤.ő¸°·—c˝U)Á]­ĺłÄđ÷•n“€¨úŦ҄RT®Î.¨˛k`˝Ý^kUᯇ^."•Éýłŕ–ĺćŔvÉKć«Áú,5ňŇŮs)n”!¦éťX¨ŻŠ”Ă ”shWůő?Ë`͆%ë´•Ď_ěG…,ĚٰDüŻÉÖJ1ęńôRÜőqDśßâc™nƧ»*ĄĂĹr点!äąÓÖ,Ř÷iďJą‘„3í»„LŰÔF­!uĺ/X 9{eě™@IÜ{]«—NŢ:™`P2­ć“± A[z—…|'ąşÝOS+3?™i; çě§”&Ŕ|b27č~ěCx¦łďNPď'‘E(Ś-AíďÚX—’ý˘|ÝI´–Ú5>ëA™:´AT›&ňŕď—’›1ĽďhŠ"W6$F]%ł´9ŽÄzěLŔ´^Ľ¬ľÉE‹ăC쏊‚•Ü«çZčźĆ‚ř95|ٸz"˝+‹Ę´źsse1~ ćYÜWf¨Ňó>ü\Üô´¸µ+50ş/·äyČ óôů|1FđŔˇ/M{ Ětü^<q{T1©‘ľa>Gü7˝ľZ“ęc1ßŮŞ«óô”O÷«ţ\\+LSĆkÉđ¶ř§›“^yÍ2Äéßß%8˨łNäŐĚŕ‘Âóź¦đmž˛á(’Όኻ L&°»łŘżAď9Őž»nJ鞬~s&Ąg\9Öš.ę\ńtđa3ůˇ€ę2CC…zď޲4u4b®ě ~XU(L]´ëŢËšąCWřŞ‹=ZyT|C‚B´Şćˇ}as{–TbU@ť†cĆűŤ t“~ěoš J>ÄjWG…@‹°Óvž3˘ĄwM u-A˛ć7Ü”SX6lVÍoř˛G{ąUĺ26˝$ZěśG6PB%9îTxđŕäE.fćô5ÁĽUóęćŰäŚe¦ůóYˇůe6eĂB™L"âÄÂXě"Cf?W´ösnđă,V_9FHţA‹®jTšHŇ“¬zsqő† ;]­íĎy«Ä|®QÍé|—ĚĽd€ źë{dgV3ßoŞş¨!ĚŢä{DôJ#Íđ;D“|ô#pü’·‡±ŐŻŁ[fmB‹(R!±ú$g W,Źţž8żýxV ‡fĐŕei<¸FZ*ą)|üÝ'Ťl+tű6Łw»Tŕ9dËÉ$ç2&m¤ą”hýýpTęo%m˙_ŰfőH‡Ă€a¦9şcşÝݦ»ëč®1ÓÝÓyÄŃqts4ÓťŰ0ÝmL3|WßÝď/x/ß‹çy8sĽ+öJ`t @UŢ09ËŘZđ`0j6éˇ!ޤôú®^lĄéűj‰Ç=éEÍh™Č¬–%Ę'étb®źm¸ 8ҸӬpëÍň.­CŤ* ď¦ŽSFÂ^ç*ŔÝ"Ľ.cK™«Ďđlg‹ ‚Ä ŰâĺY&Zăa Ş˘Ĺ©żT÷w*fŢł=‡ä)NşşB [˛Vň]úŤĂ—±ş˝ŇÉŢׂY^0Ż4á}Ř3CÂ%‰Ą¶ű2Ɔ˝:ü=đÝî]w‹µRťM2la‚óŚŔ5RÜ{ÖŚk}n%\;Óź€łs€ź’¶zé· Ń  #Łc†+oŰBpĂ “3‰ÓK¤"Ťľ.Ţ\T9ŇŰÎ<« 9ięrh4f—·y™ą‡SöźpĄ>ÄŻů<î6j đĘ^ žĎ<ĘÇÂůđËđ«ŢW|ྴ׺­~ÓŚď)n÷Yă!ĐO ŔŁň-šŕ’ Aó’•ŮWĎĚŰýH@¶Ó¤bÇZ40ÜľîDăs;«×ük*´ÇW=۶ë¸5/5)ÖBéú6=węęýćŕKeËH÷ą€T^ #a}v%9[ůĂ»Q÷DUâ>€ŹţťBdGö^¤ťmV-ďë&MőmtQ÷Hí;Ë®M°ÍĐz=łp¬Â” ösÚăg„A~ Vť$W.?Ű%3~ Ş[ޞěmŐóůC˙Hĺ a׎gÖ‡x¶ňmv“żWčoŚşyy>Ó5+Ä nëäpQ8ĽŔ«ňPVĚB nˇP¶čÄ;ý6ŘIf+Hî&ˇ)%"’™{X˝9uŐÉ· O¤Ő9ĺľĐtďpgY7 >,“‘óţíśäżH&ÇFĽâý9ń1‹Ü·HÔäVŠŽE–P!Iľí‘úí{ĺµ]xx’ć~—öÚĎ`ů b\üنX˙~*¬=ÂĎÔز;Źz şŠy˝‘íÇ-Ż#rŐš•~»ěŞ ZW×R 3T%˝':˛śP¨P|´÷:H+ oú1Üü*č+ě „ÓúÖµqzĐ9ňn:ĎçĂaC­Şt«Y~gřśŠ­;ŢĎúŔُ‹Ţ­Łh˝8ŰrÝő Ţ×TaŁěˇJ¶(ó˘«řBaáíMěeŤrŰëżÂ ŢdXĎ ĄDÍŰ1ďâś2™Í8ŘĚ´Ë•Î4öŘy$ggý*TF:Ç_ şK‚PhH_řë;ŕÄo˛iBÇř˙čočÉvŇ~ŐŠ«.6T®¶"( Q¤N- ÜéVłÝęîý`Ębçsˇo“N/ĂATE(őwŔ¤ µĘę~’‘IYk“|}9Ćó–1Ý-řl@.SÎ bGŘqOtlh{@™ÖNťíb=í1‚"uŽ%ŚäQŤL5·Äů€É?%MÍ˝Ő Ç$ÂőląŠ‹,ČźŹě !6 ąM­+ąú˘}-}U$ű‘<˝dËU3©ślď%ĂĆŚoČ5˛dů_!ŽyÍ·ô‚Lă€+`u¶ş€©e¨ŠĘá×·T‚_;/٤`Ú#/#€öÂü®eđ- 2<Ň*ínΙëQ¨,,„cňä:ś ą‚Ş”/Éź®ĚžŚśňłžě‰*Ôl`v|¬#âÍÄ%@×ŘŁoŘřšdĺ1âĎŰ'lĹ3PF6ź0R† Övě·D/«ÔÜŕ˘bGí„Ůř®Úë ątѦG…ç·uÉSáŚĚč©ŮwŮ÷Ć8PŔld…\ ˘Ý+9;¸â';}¬Őć„d·śQçXÇń:­UBĽP÷¦)'! UŘ~ KˇÄĘĚy!dI­9ËÁgd'ERÉą­;ÚÖ±“¸Ź‚$ŔJÔÄŕUXSŘ÷¨-đ¦Y­Ă¤ÁÝÓ›xťň.Ôˇ>ůÓZáďQT”ĺ€cÄP*fÜ•e—zé.”b:©ŐlĚ˙Üďę ±ŠŞ<čww6)ĎG šŔ\/ýcś=…źĺÍ´Ń Ët=ľÔ ń+­¤WéG’]Şvő°%Ŕř›“äÂî¨Ůi»|%+u?ű7°ßů^ĘÓň÷ěŔJ·Îű[`ŔD´ú3+şţ޵łUä ©VĹŕ™đRĐ—0 Ěú]żĹV—ő-ҩӬ´¨:ZV:‰Q’ś:ZÖĂč0ýü=GŽ‘iö3bn5?Ŕ—#§ąŹk•uÚÚ|A@‹0ŃŠź;°_ú¤0łg]ěý®Kho}Uk×ôSˇď§_—4©ŽµűÎjŢ@#ĎěĹ˝F®4-ŚQáqzj8‹ š;ŐĘŰl/zHrÎ:óÖpÇ`PĚşw6–ü”r‘ŕ>m Ňk¨'‚iöź< Ż™Ľć-ÉŐTŁ˘Rż´ńy7€zgK4Ş,Tě%aKttżŠOö#ń¤ô®míef8~B ę…ď§‹÷—đëá»âĹ>S–gO)Ű}0ŕ|ý9‰Ćą‹ ůs5sFńlšCŹäÎ{ľéÎ"`l ŚűŢóPîĚ{Ć™ôÄ/ś­•E×­n(\/śęMv-źXż> /Qßa‹Pv…ż|Iůp«5ë)¤ť†±;<ÔŻł$ßßPĄl|ůĹŻŤŚ\ŃŽ·ťn?îyM^7^Çǵů~Ţ+'Żg:ťQ¨};7ŞVZ"BáŤç^ŤÖţĽą ‹‡«oIŁÄM/ 8˝Z­ł÷A(>?<‘OąĽĹY[:KźyzÚ™…w8«:&:g$Ě»{ ĺÓřę!»M<ˇÉ[oË×"› €äâ Úę&ÝNi‘ß «#"Wýŕ{[N×ĆäľůŻY~+T©ëŹ:c ŔpeĂE™Thw3• Ťp6+w µëFáťÝ÷v>ăÂežhľa‘Z,Úç{0Ď=CÝiţ'.AžITâVFỬĺKćťĂéeXA>PA KÜ˰˘ťz~ŔˇÂąŃ‹Đ"Sł01şťĚ=dK&*Ž5vkŘéSuóoýŤoĺ%;™D'Ř:VCÚMČÉd®Jí˙ňsžÝ„ '»)ŢKKí›`d¦ uąí?:`í­…ě1Ŕv´wşVľ—Đ­­~§Ś–3B§öřt»řrn˘|ßîťűÂŃ=ĎjE™:ĄSĄ…Z@ř”cÔ ˘‘ľś<4ü$-¬łšŇÝŽ;ě‹ÚFÔ7ošôý÷ď‹[ďA›Ü)?©>}VrqáJµŚ§›űsvź˙‹¶çűń›8žsOZč'\0ŔŚđ2PWĐ'´ńµŹHF 8ł2f="q.8NńŚôHŃËt—Š2Z˙´‘ ÇS×IhF)]Đ' (ië$z̨›?äMi7Ń:‚fŁUÝwTř^‹x÷6ä9&—<ިXĘ&=U˛ŃŮNš/N\‰¸Đ ÖkجAQśĄÔ3…»sś9Ť{č–â­ŹÖg@¬ŘăJ=u[’HÍ×Ćg”Îv<%×ň·ˇPş!ďXł˛SµOLUÂmTyM›!¦â$4⟬Ĺń~>áŃŹúŠ‹ýŹK—âľgDŃłÂ9nQĘs˝;bׯț8<7^L ů"Ń”ˇîŮneńÄĂłĺgc.żÖBł.ײS‹•łđĚz†!™šŤ3Dôź3Ępcsn9yďµµ[g´ŽSÜ<)łxpb”$7˙-1 SşĆ ¦źĚ…(qÝ{ĺ’„)a*± µďłG·F| }_Cíó´żF—ůÁAT„Ň·Ô`ĹA2ž¤Ű»×xŃş<Şą&vżëĐ3OUÖ¶]4DôëŇŠçW7“膞®Ţ,l —x§Iľ=EÔ•đq»˘¬`m9µÓö[ţ]°‘Ý„»püţlŻň˙ŰŻöżWĚľ Ô!Ҥw¶/ý“Űs•Ŕ›zdŰ|ĺ®ń5,\+‰ř|n1I9¤ËĺxÇŻ(?…&†Ę¶%ż&§ß›ÍˇÍřĆć â®Ď ňÔăö—˘F ú`ŃÄKĎV®^q˘zź8núőąKŤ°ó˛×ř_‡·šÖËĎ™Ěo–l‚»~lÍ;çDşęęR‡U™Żúeç'š9-É’ÉŽ§îF\€1đčšě¬\pkŤ€‚ĐÇÓ·ťËz5N ŔČ*.cŠG| ¤ÄzÇŠóÔ´ ěŤéRÇ'Ţrčĺ öÝ»íR öZŔvÎIłkÂ2OĽß>Y“~mtŐ” ćľË’ la6ŘPx‰Î,aď¬9Mó̤dł¤SÁ-€řVßçµĆ/I’Wpr&3ئ8ŢmęÍ3łV×®ţ%4ę. ܦaţżcIŘţ…ůǬ9=µ$Łw/=1˙źuéź–XNîżf2Ť“ŮÁ‡ł»+®ŔEŞDűaţĚŽ ާ·ŔGʽߊN†_3Č ÷tČ#('š8~w÷ĆţŰŢ24č㪶IÝ,ĺ“~@€\k˙a‡ő›ńÖÚМ΍XŻF97aji9 <\ţ¦l;n[”[ŤiX ŁëěQ‡Mč|ăŚ3-–˛[qî‘ Ë…lĘÚĚ8ţD>Zš `Fç@©I!ňWčÄÁu$±źö-Ątůg®Lé!51¨$Ϧcť›Zć I=b7Ux…OEá5—VŞşđ˛PæÔ‡ ᾡQ2+ßŐtj«ň€FýĘ8î’°ŕ!Ź‚S2´N¬Ą?îö }*%đpiQ>ÝÝ…%Č9‰n~'0ůůďžDŰľźč©uJ¶Ů©łăü–łÜđ#bŽä]şČ ‹6óçÜÚT]72ÖjŻ)Đ1™Z»jT‘˙]WĂţtFÖUˇpđVx~/ů¤™  čŚĂ‘#*tEŢ Ű €\ŠWü)"t0iCQ‚Ö"ĄkřŹ­f§Ŕ–?^ů Ć?’»Í= m¸­ŠgďÍqHć% «ň9ÂźÄđ­^)*üNŮç§±h7 „ŇälD!|Ä\&,Č‹öúř¬ÝZMľťß5EůDfČ32MMştŃ^F¦3ýĹ{Ľ(R¦~ăşLç1˘sű%ĚŤ»Lx`žÜn ĺ%Áîć{!ęŘ)&ůOsţ#D ÔŔM©ĽŮÉ8s˝ ť‡ăĺmŕ$^™jőöaŕX‚†REÜtÎ ]<Ąp—ŞF=ůÔö—Üęş•=‹„’ŠśÂ$¦Ń±‹µŃ—Mşş8ŇŐĄ]·™źć§Ś}|× (a¬»ĸET$­g fťBő“¸ôȉřÉđ/ź¸czďĄEË6a.;°ńą» Ë~…d†úáÇ|-JN™‚„sxÚÉž™7_ÜĚâ¦"ďŢPsIjPŘT”ĺp%rP~kß1oÍ Š|Ů3ĂŚt‚ąď+ŠÇ¶ËQ}zą!kFQŃďpks•~‚.q\L”]éÁ–íC ě“}Úݬ«fĂůđ1ÜYřţM ĎÔ.ŮştÜŽ’ä i&ě>sCéŢ·´Ż%Ź<ŹŃ®ó]aě?F“!uq5yú4cŹ‹¬>Ř'ÄËp«Âá—I}ó5.ÄaĺÓ`›RE2]Ź=DµŔ÷¨×®¬Öz¤şBůaŃ{ZĽä_ŚŻ5ű•C!¸s‰‘ubˇ~ČQą>şl×Nŕńű3[†Wń,ŁWŔ;·ßŮPr¬(69‹ŐupÇź&* nyh¬M±ĽÁÜšé)ä3cU&ł3Ŕ¬›ő«€đQ†\`@ýââÍ{»¤Şc–’ĆžśbžP"Ĺmízy&¦˙;ZĽ)ŰD0éŕlÔ§--“aµ ĎĘ?DČçľë:”$gˇIy _ yÓío•‡ý$ŃJß÷)®PŚ0Äťłd\řěš>Šąë&Ë:XČĺD9!7I: :–*J—/Jnů…j·™›»™Ć@˘•ů®#N÷uKâ`x…eX»áyŐś„/ˇk[ň‘±`"ÖăŰ Ď3-}oâ&•ćÜuŔóE !}·Ňiĺ#"W]26~†×ˇÍz-^;'EůµîĐÚ«kPOiňZtś<|×Ôqz‡–q,9ńž$/¸ľáÖ>–đ^Űô. v¨Ž{°”nHÖ$˙]±@H%vŇžn÷çÂ!!żű{h n]ŇkEĹG/łĆr­1đâ·ţÍŻ™Öp]î8âŰ(:Č´˙++~≔9‡Żv`j1ş˝÷šeę{Ę8ü©Y÷dD]Żh<d晑‹¨‰(UH©Í.™yIJŔ«ŞPPHĹÚŽ„g»§ÜÂŕ02á0řýJ@n¶…b®ş#SEśL&ŘŐĹŤžŠ¨€»dFŻôř+0šgĆΖ4T—ŕÇóďuO˛ń"Ęý…ž‹üŔ˝ť6ˇő}hÁ%g“*‡©ľů·žl®Š“IŔ~ÝGGąGrr;WĹňvyđł  é]»ľ_§Şyl߉ă ËN_ďg‰ťĂ庣ĐNQEŤëN»xĘb]Q§ľĺhŽ=Đäm)Ą!‹ĆĽý¦ˇĄaŠĄyŚ q”'­i’NÂCýÁŤŻy-âŇČ?+ŞyEśĎ}Ť8‰ĹbźóŠđö,Ý=3ˇ%X[ĘrˇeŹűz'ÔźŚ–ĎiůişÄ™–„XPŔµďt ă„­­—SĆ8‹»ĂĎ8m9Ž'áÚßôF™¸+ľC‘E3řg¶ç¤l€÷"2™OlŁ:&Ă]Ńb éËşĘő%łĹÔ«hN/“”ďt˙/ÎV ŞN°o&dişcAÂ…p,¸`ýLěD¤Ř¨\ĄÍ@\ĂáűJë}Ń^ťwđŕŮpp›ő ‚(…ďI÷śżĚ ř˙ĽoďTČüa^˙HăÂUő/ę|c¦YŚ”BřJ˙`şďé>+ƶ KôX#Űş†řÄáĄzzćĄyÄ… a±‰ýé yüÇžŔ¡@m–„Ťîš©ßř@ża^FńŃÓÖcńŘâ3Ľé…Ľ7J\)‰ĘĚËwţ7NŘ˙,“¶âóÚět^„±Q1Mň&䩨¦Đ6őb$Áľ2ţămj5bŠ1ŃĹâÄŽ°iŚ3Ĺsš¬¸ń 6Ëź?N·˝…ÍVPŐ šg—łÇ·änj8N#Ĺç.ŠőbdůѲalĆÖi®J!ąN|–®bv–eŇýáÓ[-‘t[¶ďH¶÷—˛˛HĹ˙ĺ×lKę@nČ> stream xÚ´şuT›Ű¶>Ś)îR w-îîîîÁ!Hp)V(îĹÝ)V ¸»»»Kq)üč>÷ś˝ďůîżßČHŢ<ĎôąćZkdŚP(©2›L€ {0 #3@N^d’ł03€lͬŚĚĚl˘N@c°Č^Ě ä0s1˛03˛23s#P$ö@§7Ú `₍Ő<€,j㿀ČĚ`běü&Ú[XŮiŢLDANV–`Ŕ›ŹO <ý±ațڀܜm¬ĆöfFyF€Č퍴Pě&@Kc[sČ Ô¨«Š«¨$UŐ•Tiß«ş88€śţ'QU5uIz€°‚š8¨ATWUűó©´7:YĐÔŢäâĽ)ţ1—WVÓVgaúS€ŕ tr¶úöżrŁ|Ë đwjo¦ćN »ż¨-Á`&&777F g0#ČÉ‚ŃÁöŻüÔ,­śn 'ŔŰÓ h ü«1.öf@'Řř/V ge ´wţ1’ýKh÷ÖĘ7Ł7üźÄŢţăÓö_ęg đ…±4vţËVNII`gleÚŰ›ľ)‚ŤÁ.ÎŁż¸·7ĐŚę_ ˘.NNbČ˙[äôź0˙N]ôV™ž­—ʱŰݱ˝‹łç?zóżË6Ů;[9ť˙ĺ0·˛ţÉŢůĎšYŮ˙ĹÉ +HK«Ş1Č˝Ťś=<č­;öŚ`wđ_Úü ‹Éń8ąŘ¬,ć·ń·7ŮŮ˝eíŚđ§}bVo}ś<ţ{ měAnö^˙ÚÜĘŢĚüOßÍ\Ôí­]€Ňb˙ŁüF!üÍYÁfĐt7µdúěŻYůCłüˇßšŕăĺrŰ:}¬Ěo/gcW ěäôńú§ŕ#N€™•)řmĚß¶ Â_ŢĄíÍAîŃo™ü[ô?@ýץyŰťf {[€ĐI~ę˙vŮĹ’p±µU0¶R˙WG˙[ÍŘÎĘÖăż˙KGř'Yę˙ĂÚĘYÂĘh¦d6µü«‰˙˘ĄÁĆos/loa |[’ż(ő?[ÉömfßΫ?€…ăÓÉŢĆŃÔĆčě ŕbýK|kÂĺűÖů?Ůä´ĺU´Uéţ{`ţŇ·7™YŮ[XŮ9ĆNNĆĚoSŔĘÎđbyg3 ű_c`b´ßL.`€9Č áĎRr~0I˙ˇţ…¸LŠ˙A\Ě&ĄżŃ›¦ęß Ŕ¤őÄÍ `2ţ˝ÉLţFo>M˙Řßd¦ Ű·¦ü›aa~ cöČ`ţrüAŽ.ƶ˙P`0™˙íđą8ýCţ–¨ĹßŢänŕ?UŘL–˙lěoČĂÁřϤŢ8«Ŕ·mţߪř;#Ž·l˙,ĺßň·šíţ†,o ˙đÍňVčđ-C‡˙ŔOo‘€Nť°˙Iă/Î ôw›ŘŢŠt°uůGL–7Ćńđ­ÄTĚňVĎßĘěoBg+÷ż˝˝u¶5v¶ü‡Á[Lđ?ŕ›†ËßkúćíŻĂŮäü‡Ö[_\˙ßÚŕö7d}«Űă/řż]éĎ!˙× Ćü÷ä˙Ďí÷V;l€šVf`ËŞČť¬Üu™ßŽ–7ţíőďoú˙+Ĺß'ç?¬ED@î^ lo­`řô¶žśźŘţŚ·Ď˙25ý×=ô×É÷¶C˙Ť˙\ Đhа82ĺ ˛Nn.ńĎ›(…ˇŕf<)ÇĐ’‰}·6ŃJ€'–˝E Ě÷oňK§ĚÉIńčű&úŰjQaŰľ¬ýH¨ż6SÚ6ö•÷%@ÎŇ`TH—_đ+m#Ą9”ÉĘŐ.b›JoŽm&¨‰r·¶?D˛Ž˝˘˙J"Ő+m^Éq+aiÄr˛Ĺp_@űđ“`aâ'$řő+:¸Kx‘vÚ(7gXÖˇłM‡.9WM;m!Vű.ż¤SNązÇB/V4ůpăWűý’"Ô”‘‰ł‡>ÉĎ«¶Łń™˛¤ç3ä[“˘{ĺVHjH2á%Â+éP•voÁżÓ±Čżó´đţ¨¬#`Ş€ŽĎA§"qóYĽ°Ő"굉FÍ2üÇ‘ö—¬j`Ť%eÄb˝ćnµfŠQ'ÁĎ v˙‰\Ě2ČjňB›Żú0Îş>ľĎô)I4wibpěŮúézmĹ$µ÷Ě-¬î×gŚ čŠfBłď%‘ĎPˇU Ú:É”ą–»ÉňˇćÁÜÁĐ]ŽžťaŹ0#><° Q ćχÓm“ë—ŃWÍKż†í3ýÎÂˉS–Äănżą·p%™}óžČĚ­Â5™^ÇČ#’ÝŤŮSy·:bwŁŹŮăPŃtÉ©VB¶{ŘyĄKĄ˝Ő~%§Y/˙Ł/ăěIzZV0~á&J’m‡~_üç©›¨m]Qą ”fŕTşę÷(ŚŇµű«ŤĽťĎyúă~ť»ďÍoçk5óş2iŕjoěůą[â"¤‘™ Ź‹ä†…0Ă&şxę9čňrWeä°Y±Oíe ˝w%žQ3SĹ:«“sRËNž°V‘X‡¬­ˇń°^ď?ÔÚabđbfíT¸eˇ¨¸ Ľđ~ŢŞsŘqFŹ Đ–‹dę=f€G (ˇ%ŘŽ’ hîć,q©´7ŕ@,ă)ă0Ľ>űK[řŽ6Ł5Šś Úôgt^ ř{¦óž‡ktEšúš­‹ŚqoŚî8íúĹmÖŤź®jLňÔ®­§Jw?h 1ұńţ(AD ŤŢ‚ňNÄÉMŞŻsŔóšJXQ"ů}ˇ¤m;ú »I·\Ń µŁ?‚?×±ů“EEČ3V¨źrĎď-¸ <«ßTţş}ĄěĄąâRçAĽ" ©˝džřMŚ(Tt÷ź`ł»‹3Ó¦ p78pµň‰µZ)ÓË#ôNę¦ÓąĺuSgĚ ł‘Í,aĄîW®=S2ČJĂ Üx,MśZ¦ôŇ;c-9lj‡Żť—¦[J˝Fűé.7Č<Ú˘ůyóTŮÚ>…X’Ź­v†ńް‰Z <í`ŠťÚŔÍ©U‚‹îk˛2K‡8ç’q‡G5ěz S•mUoł^ëç9îőÝÓŐ•ÎűÇ á w¬á(J"«‚Ń=?e˛J+ëÔ ?]´ňŞzóiĆ+t+ßăi0Žç0…Xó¬)I,ßöű=@)“ô«OËJĺŠĘ!O`”ŕ…•”-fWSk§¨5ÄeĄ„íš«;Č,˝č¨n%Ţ2Ž}Úz %ýŔV3Hk3v÷ęp´¬Ď’#9Řé%»î{\;ű4´ĹŕŃ3Äýáj;Ňuä{äWü¶SnhXbŇ`¶mk̶m2Ϣ.Ż6”ÜŢę—‹RJşŇUTŢüfĎ-xcC}ĺ°ÓÖ€÷ÚÚVǬTNa‰˝aÉk㣾5버:ćŽÜ|ÔÄëľUŇäUÂB.›^ śö'äłë:—«Bž—‰ßĆy{TÂs_‹Ť”31]ŰŐţP‘ü`|• icâ2}&Ó Shďíőyk€‚†Áś}‰ĎѲőŃż‚ý ťűѶ6ŘŰW+RtCŇÂŢ,żąU@Đ\JA~7ÍżŐý ę‡uuoÄş“±iv‡1ó}m>sDą“şeąj:íd#µ}×Î ś6‹yř;«pľ¶hJ€h‹­ă©Xjśófţ§¬Ë–†$~ĆĄß+ó‚ŚÔź÷xúîľçŐ{ćKš Áó†‡NH|ýĘ8`'hhşA8đ»lG†Ż°\>żcżüÄ=xúĆĐNĽFađrK·š¨řUéçţbŻUfügGş0m”_›•MÁ÷?/#NWîTŁĘg uDőë\Č[ę yaftvîOR˛.á»a^úź>cÔÔÎcîâIH€çcÚŃ„ üŞř& Žäµ"dˇźÜ,uf(Wb%cŔbż‚ RviăPśů¨Ţ)×—Ä ¨ÁÉ×jQnąnĘOôĹâöÍ!€íhçüóéĚŠ…­Ż•ÍGôł_ż±‰8[;w&-G)„$rw‚iľ+}OżMo„F·Áéź”·4ń䵝ő«¶Íyia¤qG­úkŔ‡,‡QGĆS•S‚d ŘÂJ „ąbz^h†’u5Úş’ľĎ"ěrą¶§Ę—Me1ĘőÖ4Úf1Ľ×޵s\ç'±ęn‹«gÔëL¨Ćŕ¶©!ü —|»Ů9iňŔ7Ü_ŚŠ¦ŘüüÄsŮŘ ‰Ö˘O`ű\׼k*úß­Ŕudq`yĘ˝łÉ_bÄÂT %ĂIŤ ,Vę'­RťaWŻ!Şľr÷.uČŇF3nÜ‘çĚ„2ßyuR;N©ľ:Ž5…2Ĺ8H4úäĄčvgČHĆŃhŤ>)“·ÓżtU±çZŢ»MM+ČÄ~ŤÝ[?äŇŃ,ář 'ůüNᇠ5¨e[i„ŤŹ»óašľťd°ŕ+Ç$š&ćŮĽťŃ´WÁ¸Ô˛ —§Wn8. ľő«łyÇçwS«ô?ŞíXH‹8EUafű°ŇžN?ÓQ4 YěćG ¤Őú]{ &JHÔ=Îը¢ {H‰±üÚ˘(ť»uŞÇ-ţ&ô•ź«×ąŮ!#Zqˇ–»xő®Ěęa˘Ěýh5ZnHűuv%ßtě&üKĆ÷1ă×|ymŇ-ßS>ęÜK‘&ŘoŮÍžŰ5n—đćš$ř¶‡kŇ»­ź…šť4ĆĹbw…7–#žpů•Ł3”!żŐ˝LšâŃZËďůęU·ăÇ—ŐEČ;©¬WmzmoWQű9)˙úHÔ/É qŠ„YbJ’çÎLÚÓ&ńÎę•}ŠŹIU¦Pđ‘ôĘ7úxfOă6Ă!ü˝ÚP-/Fí ÔĎŠ)űŚ+Ż×ő0Ö5`¶©ĚÁˇ™ÇФ PŚt~ íaXrBJ¨cűÇĺ]Öë%/©u%U4^wŠfu©ůŠ0x.¶a{\(+ż4djJ6qZŹëCŃÔęÄymŰp?ňµŐ1´ ďË÷Žów_0_®áŻiňž Úuç=…ÂýMÁäXŮQ˛ČW_sąg U|‹fó’CÎ&úľ\—™Ąü^@‹']G‹ŢŇWá]€) IŻ‘óQśęŮńÚ˝éý@€r2Q{ ső-|y/ŔÍ5öýŚfÉ]‚ ©QňŠ1tăŇrf’Fé÷xϵ÷0 vRŃĽ¤Ô÷>ł7ĺŁIăc˝ż@ôńFÂ쏣 Ôríe8üAgG¶8|«\·H°N«ťÇKo^ۧ’lj›ćS<ÉÁŔ)Şg¨<EĄ(Ař›xáô4ËFUaVT‚>ěZ´ßÍĘÜ‘Č6”ńÄü]ćśhşüKÇ˝cVdŤdqăŐ4D§'Áˇ%Áź™é\ůůüĹŻl4T8AÄÉ"\(ë”ć¬Íϳދx°&““‡ë„EÁÖnŚěk%Oůç8Í|Şý&÷ó_Z;(6{Ëă „nĘ Oč—~0"ĂW󠋸Lýv"Śţ5öńkňTĽč'…ŚZc'—ş¶ZÍ>˛HŤśßŚßΫ´ôňôčŵiÜůłËŻŔÎü`I<ë†N˘ ˘›Ł4öÄĄČE´y7ŔJPżY7=ÓŘ;XĹéőŕ…æ5ÎOWaĚ;]deZoËĹó|¬šě™(ö•,–<{!Q5¦îµZ”á2öFŽŻ“-18rń™Ł”üsľI¬Ş˙Ě/ZvoJŐČńŇĎ'Čë6a·]Ä´¬_Źźř,ŞŔ‚9µŠćĚWD1Ć]AâźA8|…ĘÔ©ňŕˇ)bşĽ@Y_Ó…ö“Ôq–>‡ň®_ŐjůâŮüíß§&PúĽ#ԤʹN.qĂUŢi‹É˝ä‚Ť˘”?5Ř%&ĄĘҢÉNúź„R?7Öꎼ#‡HL3×!Š7|v» "'źÓ /'NŞĎVéöNýA¤ Cq}¦?÷‡Ń€­Oă°ÂŞ‹ŘoÁ …—AP©!Ę–‚ď>^s‹Ś¦¤–}­¬‡>FsA=ŁĹµéWa¸nP4 ˝zzˇźÖ]䆿#0·lMó…m‹Ů|:†·?ŠcFěçČwm:#rzúľöaĺQ3dübôDÔ9´Aş›ÔßÇ÷) ŚÄN=𚊟 ÄvÔ`–f…$ĄŚ jÚW_úÝŐř@ˇĐŤÚt92[Ý•Bŕýtľ©­tGşďŽ4ůĘcˇż7^ĽęÝĎř5îÝîjy$—Ý‘ĎĂŔ‘— Íŕ<–}ŇťMÁ4ĂâÇCáKű·Ó!,çDŐ±®šÇŕXéÍą?ŽY+˙B Á3ůÖ’ŰĽÉń“9ő#C@牨3âÄgSóS˙q1GA8Ľ"îŮ1yb›Ýş·#lHŕ¶8+Ó~/Ř@čŘ"É>„¦¸újr@‡3Ľ=Yú(„¨ÖŁc×RO×xĘdčľ•G[ůšýFÖîDŤş»€Kţ8YRvńc,oťLy%g/ć=ÍNĘÔgÖ-Eč,RQ…‘[s¶5ŤýOŇ5çf%Aš×Ä9&ą\0ÓÁE-¸ô#§*ť˘4•´ÜĺÉ€˛`NĎH!‚đ9¬‹á˛µdČ9Ő }˛ŔĺúĎŽ#»ÁPś˛ŤEzv˘¨ŠÉodIV±”yýVA‘]b+óŁôvŐy‡Ií?eiwGQ)9ČŇź÷’m%ľÎt•u/Ń»€]@ŮóLŚ„QąÚýnTË{äXŰM¶ E[ˇ$kס ›/ílâ dŽ\?•őŚtů4Ű-řˇ\Ľ®\@>€}hâąé§4áÂçÉ-¤rŁf§¨íá'j«FÍjÖĐo“‹žŠ‘_ČÝB+±Řť°ĺűϨÂl‡m+Ž2ÉZ´ŞÄÓU­fťtzB;ĹL×˝WÇ-× =ôż<â ą”—ő«ťt˝îNQ’©'a˛÷ĘÎ AÝŮńŃ#{3ťłă7X[ôť šx<Ń9JĆB$=„ŢyHČŐ¨­wuDG Ą´;â۸éÉ|ĎBŰ śăľK|Ť&=éޏ¬śđçčÝbÓ)ôÂĽe^®ĹO‹ě(őMĄß¸,íš xˇ ˘ÂWËÎŚĐŁ˙•ň^N2S¦|úţ¶ÔwQ©ł’`: e”KćuáUńlRý9u†± ČJ¸CO,3rźúüq°¦}YľÓpŕdܸ‰÷ĽŰij*č"…ré^ÉÖ>•ާ|ĘîłśNçî|RÇnQ†‰u¬đ‹-¬—Ľ€â. †™] ¤âťÇń\uBŤâľ`ˇ÷4Ďô=*?µa "ń Łw!—Ҭ*3EÔ?oĹhsó~Í’Lc`K /®rC™&?r7d?2+ýÚÝ/M*\ľŹ'†šÖx˝Ďxú<ŚŻŢżˇw˛ŰPČ ÁÝöî,n Ö%öéĹ kŻËMŤ_&{B6AE3ǦHŤD!)vŻÉh>ţŮ^xąWˇ‹_Ľ3é C8Pţ›~[ „†Ľ ÚX˘š}L1·˛đ ;ßáĘŃd…/{V+VEU4××áß_0>CĹ,i‡)c˘’ X#ucůĆ/ FĺméjYŞkt:Á‰Sm)ËĄďi_/•O;Ď?e©ł(0Żžşüt iŻúťk+w´qŞEĐ[í)ŹaÖß¶˙+8čWĎĆ3˛Ľv‘áÁúŮ×řĽuC,ÖČ㑿ÂeOžň*ĺşäk3ÓAĄcçă¦÷øŞ40*Ç­ŽRQJ˙Thltüę¶tŕ†űjál:ź+WéŘ+ZŘtŁ„©ď“ĺ¸4ÍĘ€ ;÷­&˙ŞîŘpč2alŕAÜrkÓ9Îű[Ň!6DóWPŰă§ň&Ä”oóř–ĄęĹz–ł¦5ą#'ąY•ň»áCUáž`W6úŹľ&Ě™˛Lü‰’ź;SUSŹÍŇęŇ$ [ä~Ř9ł" ŰRúÔ. +Ž;†Ő ~P-F‰ ꔍí3&ÁĹÄT?cěë5kĹĹöŁđd)í攑ĐG˛ŘĺěřiÜ‚5ěŞʨkŚž€i§ŰN§ŕŁRşÉ*m{ČÖl’ŚGúVΑY”ü».ő<˛ GU2Ó4ÖéUEÖ{ Ůp˝">H4Li8V ¬Đ.}ün‹˘$Âx'žŮ‰eíÍNżžć-IŞ‚ĂšÁ!P{F¶Śc`ř&$Öe†¦'R·ě¸ÄeeB_±8Ü’Ľĺc¸M€2MýŢeÍŤ‘GÎ §÷µŰľŐ,Ł;r¦öÄźkęłôS^4ţZŐpJ Ö#Eń¶˛ÇěŔ†möË޵ťëěčF ŰöϮӂ2YÔĹ«Ł—"â˝i‡¤„ÝĄąw—š,dóchđ°6>âý !Č5qĆkŽWíŔNóäŚxÍG~®Ů_Íqxś ÔyílNjřńŚę—Š,\Ľbď,J:=żoŻ”;¸Qřě–ÉŘeËä8&†bŤmqJ.Cčź×đsaH;)Íg± Ż_xă·Ö†<ŁŐő‘·ľ,Ú[¦Â.µńŻ„'檥(ŔďÁQĆ÷ĎM6WśîHş;LŃúqć ăśOĂXxĄIr÷yŽ”v}@ăĹĂŁ/vĹa ©dť˝fżzE„Ľ5Ě-80$'Śö7óŽ‚ëʧӢĚŹń ”^ŽľćŻĹJ˘šR*„¶ą<±đśůcĎż«?_Ő_Ä VˇJŰ6ŰĹýądžöŠ–ş=o§ë­ŤI˝ŰŚŃ‚—Ľď,çâ\ýťÚöD,@cÉQżĐß*f „„–[ó.!€÷€6ń{wŹť2$’ł ?n¬|»VOW@ńđ{MuÜÇ}ÇÇɢšü.MJňŕŕHEů=Ĺ”}/ĐxIŔä‰Č/Î9g?śçšßŽh#Ç·×ćĐ„ĺ-8ý˝)ü}ô,rkhĂ ő<ś¶­`b‚ę…$=˘Ď‡*]bóáĂž1aĺ9gC{&‰OĘţF&ŞhUІţG%=Ź”uçş Çʉi¦‘;±/;·‘CĘصËg±ć[ř«ánÉ| ‘–‡&Ô[Ăźă® '碫.«LňĂă˛ÉNP—Âť{˘ôtMËWyëęÎWěć´^ŞöDnŻp–©®lo>Ȩ+r™Tű .V"©ŕ|¦AëäŠs™‡śÍ®=Tđš@…N1ÂľHm)¬-(\e‘’(0ŃMŻ(ĹŻ$‘)îĐv”q-ďŕł‘!E%y}ĺÝ(»‚Xm˛gu»tÉéť YňRľVľ*•AźŚx”µüä sŹÖËś9A0ZIŤ@:řŢ®učxᦷńeÍ»]iEBź‚ď"ŰIčHňr×fE•ůŽ/Đ,<5’Y\´ĹÝř•Bă5ZÉ/Ŕ0Ă5cýJ´?~mí _ť§n}×ü+QZf$™7rbÓě+4'ů\kŕ˝%O nJÎLĄ~F>[űYńW Ĺ\¬n„TW»») Öq/i„­-1uśąˇHooôČ‹»˛Ý˛‹ĹWa;wĄ;%“ni`ßfĂÉÂE ś«ŽéF×Ý«ěMËő†Ę+Ľš‚l/ Ë×Ý HR§-–ľúC×ĺe̢ßęGÉd ő*Pëb Ž›ČÄOL‚“gˢE‰;=?šŃ–áůRËÜ…AöĄ)€ěŘÍpżÝü®±ˇ&°vvřeĽë©|iÖg~˛_^Ť„đľPΤŕ®+ÖůĐOĘzţ«Î77«ŁÁó÷Oď0Ħ§MŇ1Xp,}1bĆ™bŕsÍKbś4ÂęşjY|řüjŠKU]p +ŃČp­6ŚöŽ]ŁB«]„#ˇĽťNzR—“K°•}/n A©í)±>_ ~„Ď,2”oŐÁ†8íREv’(j¤î_ůUćâCµÍcŐŠćDŻr ó´źĐ áąhÁËgĚŔź^Ů”Đy.Ť*ísîm‹Ý>ă*OĂÇ"ôźdW*‹ë%§˙e?=J®)jRŚĎé:#©!Ăh΋ßŰ—c`¸!‡Üý|ĽęHM;˝‡=ĆOýTńuá‘ţUŮ­Ĺ)ÖN3‚ŢŢ)'lwc]é©NńľËé+ţ˛$s™‘řĹÓ”Ľú˝ýĄůů"/'łĘ¨ăíŃjŐ*žTWÓtx"Ý&}zŹw ‡ZżUZoűăŤý:ĽU7Bt7cDDČę|đ3j;[,PŘ3ňÎŃŘ9íFEXB»Ń>2ákŇů!I•KË?3e=ÚdTÓ$˙Łő7y9ţ`Áćčh€ż†¬±L™Á˛IwFInv†‹˙Âá ŻeÄ-ă oxM_,2‹¦ÚţřžîkšŞŽ5—MÇ&;fücÖQu©39şFß×–ëTBV•žuh{G ,ýß AŐŤ Úa"ޡF{“ FöYż…Cq%şţ*.ß26A(ŃTźK jR6˛w8ERkĂáXK’¨]ôŠtş×`ŕµĎŹŤ&GžHńËŹ®âr% 5":ăůę¶–=`+E*R´ĆIYGô·U¤Ö>’,Ţđďv`± ău*ĘcSQ”ŹB†ČĎ’_¨€vFÍŤ”ęÔĺĆćU—UćJA*Ôü7Ó§â Ă ¬Ő’ĎËđď’á±…č·fQ%*Ö)R¬Ą±`›k|(Ú'Äm %ŢĽjß [sÚĽŰŃW°©SšĎtŁ®1X×W;uxŹ KŇ8)çŠ/éUioV{HDĂc˘^¸ÝZŹĽ“6ăŁ1´gU&öVilq©µŃóňÁX3%Ţ\E”ŘÄ;ô"ZެhÝw­9ĐŢđV ÁĦˇEŚSW,ÖjŃßvă†@ěÚa× > ;k[ţD•ڦ“JGI§¤·‚ń–.Î1ŘŠŇt˛°»˙u }%ƸɟŞ4V7HţMńŇÜLŃ!N˙sóäM[mÎçćš»ąšKcŃ$#úć€ępä™k3Ľ–ŁźĹn ŘĘĺ×xř™ÁT ›łůďšętŞLm;!?f{ˡ7a…MřáŁćsž˝L«„e:eşć Nřm»ĆŠeŁTî|¶×$Ţ´ŞÖŮ1*IyěGFEŽ.Ť·čY ü!Γ‚,¤Đä?V“rŘ×ČëŕŽ“Pźl¸ěűgLo5±ŰS…~ňŞiÉ Îžżđˇ˘ĆÍBšŚ„ß Ę„?đ 4¦gŔ±őć‹Qi2ž1>´¤!ćVúÖă鎟`ŤçˇŃÜďčëW…*Q ©`LN±—Ěż¤_üâÖ˙ťÄ{˙Z`ĆďYuxŘ–&›¬_®$ă ßŕ{-µľ§—gü!Ň«ĽEz®Úű©Š—Ůz ·€ö=,±ćWahÁĘĚ%Îg@y|‹CQy: wŤÓÖ/†>úÎöµyMîÜĚĄY|Žî|Š{!÷C_YPž˙vżĄµŇ*™Â>ߌՖlrfcަj]qëC°‡¤w*dÂúýQT;ŞLJP× ±†tipË Z2¤Vü–rŕĎ0 ćXgâat±ŤĺH8 ”Ý׉ŢSş¦›——ć*öŠűúĄůGK-š|Ż˝°ŇŻěOYń$p+ÎJl7,j963ĂŠ7_LF#IoRe}݆Ë(¶Ă$÷ů&ŁçŇn¸5PżEĘĄÝ´’Uźc÷C[ęO3 ¦É–.!޶P“Ó}G° 3ŹÄ­_#Ôf YÜ"i·°\Śj± ‚ôTŻäB>áq!@Ęg4uQńRĽBčŹŕĘŘ‹hÇÖ¬–şÜ‘đş§řń=-’\ …–µí6~!Ő:;«Čń$CńĹÓÔ’”×qÖŹĺž•»n«0ĂďńŚťhÜ ‰$÷Č‚®ůC)ľh{7€ô†Ô(F=e”*O©ÉSyač O]ĹGÓÓE¸`]Ţ7e86ů«a#V”¦RśąÚ,†m2Jt“'D¦źÍÍu ŕś"Ü ;?(ˇŠ,ŮŽ=Âĺeł[ńOe‹ ¸UERÂN|Ů t?çHˇó˛L|ŽÎ’AŰŻůŔâL¸Wg8Ů=GXG„ËLÔÁ_C‘Đľ;‰xŻŠúě*-7ńĘŽüńĽ\5=Mí‘X ÁСL/ó™® ©6ö~›Í"((Ç’·”§Ą\ý·$ˇăw(x[ @KŃw6*‹{«ď~ĘŇävŻZ Afąh3XxFÇÁK¶Ä›Đšo,$ĎUH[Á”¸arťŕEç×ŕw:ÍVŐ ĚŁrą”:+iOO>r¬ő㱹C/śKëm«ŇÓ=› ÄR-V|’&5°‰jÔ:9=Ŕĺ ©+nl{Y“~-–*j(|8’gěZÇ1ˇ%óđ9^~°pžş·«BýY2µ˙PfΤgX×ýýA§Ľ­©]ŕWg߲ĆďsáJČJgĎ1TĄŢRĽ'ǵýđ—¤tM©x»‘™~$RŤPé=ň…wd`,”¨¦Î ćcvŻvEä ű;J ň3<żoÎ!gÜźˇ†ĎZgÖFnýĹQŻq…{×č1-úĐ9NÎ;4î1Đésw—c{Ě@‚wÇEkKńyj hWoĎVSŁ’sE+e<:FžÖ*gb %8j0Â%î'’gyŞ,ř ‹¤Ó×`ßeŠg[†źŠ'ąŔŹ7ťŹ>đ®˙ .łŘWl$P,ÖúE´Ţ:X^»á™ížĺ-y~ŞŚĂmăÚau¸ÄsÍvĚŮČäW0µĄ?,V˙ťFíĹőţ#Đ÷Eµ›ńŰŐš22ĚAr‚Z5‚Ö}żďÎ.Áb)®Żí,ŚŢü Eht 8ďŢ  ;iq+”0 Ů^Ýqćë Úů7wő„ĹkwW8™ŰĄ2HË<…™˘Z—ĘFZôSÜ@<â˘9Y× bćŤÁµËr[-̉uh4ČW9yÇŢa+ď^+yů¸ Ňń‹LłMYµî»| fo*E ÓÇçŤôćóR<©€ë î……@†ňAďS4VÁG¦E[ ¬Ż¶žHíľ¸Śô%ʲA+ÖŚk UÄUׇ‘v´8.Ż?SÇ—ľ^GlS†`¸ţh 1ÜÁƦŻCű e²E›1qk6o‹đřy҇ťŽYoCďwĎza˛ĄŔđĽ~$Ď~OĹéN}Q*oËđE"\vd‚ńĆ{h-©~—mŃ><ćuÓ«Ö!>{•%ݸInŤNF¤´ynVÔĹŇŁČňYM©Ź›(é&–e˛tlŹ÷ĂĆ«7ŠtQ}s^/~·†¤ń8“<.ŃÄą-L|‹8 ŕęŢ}ąÎşÔiž€ĽnUV°•Ń­ÍÝ}1âyr­×C±µ1AĽ EĂvô „ }‚ň§ąÎţR‘9ˇÇ#éü9Yń@ö¤~ł3Żü©Bož–Ó©.UőAs·ě »ŢlŠCSďg&ßc›ŻX_HR8ÝĚ‘8ĂŽ9€ÝemŁĂGŔzʉ×7Öj+#_†«ásÖbiĬ’ŃyÚńšÔE+®«ßW„13©Űßw*b+_”Îj 8ÍbnŚŰ˘Í¨!!ş{›‰ źí^~4Y%©Öġ·¶HŰýÄRC ľćm3ęń…:h&ášPünE1Ă,ŞĆZî\lŻ€łŇ‹fß 5’<ßć´sOu'Z‘ ®:fËyf\°×'Ť›+ńł:D¸v#6W˘&ň놡Sćléľ8o‘ĹV"źÎ~8ýĽÉ»›ęrGóŤfďAÂçĆjé6ýRĄGCíĂčđ5"=śE¤¦ĂZýVhĚŮ•„–ţ}˛ßëádŻ]dQ=ţćGXřÜ„mBďu%ŢH HýĆyľĆ7®QńíđfJTë˙¬mˇ–‹ťRŐĚ@L“áÜżę( 5Š VCNË Ý‘ăáG1j‹3Ĺ~÷MŻB úWô{Gů8h"©ćP4wnnXФş(r‰ť*ô~~•XT¬¶ ‹_ę=bpă°LCÄň»E˛r[&Đ6žóŹ«ŽJ+"žr:˛ŽąŔ,O‰i¸÷l©˝K eíÇ[‚Ąťt…”¤Í…ˇLś•*…÷­ÁĄ\ú-ĄěŰ­•wF1b»ÖY°¦nSk,Č1ŻúËJYa™é¬Đ:ę'Im÷Ď}:·XđH2bôŮ•BÄX×- Đ𠪸đM®{b˛áÜ&ńśčËZ’Švމ–äô^˙•j¦ć+ň©ąńÉE­ 7ŠřÄqÓDI˝BŕDęÇ_X~P…ëřźCC›řv«"ÉKąűP6Uł%Ś~+nT\1iCŹă·é|(ë•˙ˇOôĂgqÁĄQ´×‚“ëž…$·ďgĺÂýĹyN÷Ea të>Ś Ë}×:Ňr‰KÔšą× á«Ó® bŰk{U¦JţÚőĂ<ÁgsóŞÓ€Ô(4ŘómqmÇĚdŃš>óK‘Ç®h{„íL®{üćg–\^ČĹě}˘'"t)Í$ą6ť9ń8h}˛w'Š1޶E16~R6őý #ĄYČż˛ýôұ#ŽĹŔďDĘĄbaĐ‚8GĚ™ď’îÇtFĄ5ě×9ϸ"ŃĚ˝Ň/ą+]YË’Ź;6s)‘ŇĎj ¨ľa‹Ű: ÎNä+RH°6ó§â=3“Ë˝ŹŐ§”÷Fô C„L˘Ů˘ĐĺzôÁJ‡o-Öl"ź”ĽG5żôž**á`ŚZEGĄĽW°ô;="uۓɄĎÓ‹oěŢŹŐu8Č ÎjJ–¨ÖBř˛›ľéz©‚ţnőÓ|w‹®Rfy˘ŐKI燭2ÄY箝†ž>űÚ}­©îˇB÷'ĂÖwĺS8ľ§Ł%âČĂ·€}Üř fžąm(-SD~íG­ňôt‡śPĽóŢ:]%†Éwĺ3+ÁŤÍLŃjŁ˝Đ/KBé+Z ěťr‡ś{‹Ój:ßWKq!Ďm0ł5 *^qő&Ź*NDżmÂôX\謗wEÔWIÝ'ř¤?ţşůŚj+3ß—2c0ď͆S-¶_ęŹcóĂŤ]uçY†g;¨Ť?­ŮĚQ¤¶Éß î”QP ˙€§ŕ×ĘÂ)¸ěŢ@@l*ÉńWč˝6ZĆtů|‰öüúCĺË]“aÖТ'Ňt+şŰDůBě÷0ö3g#auĎîŇéOřÓÖVŢr­hß/¨™©ç´Ý A-žwa·~Ňýp»ĎXÎűëqóG,¸ąă±}ęľ[§şrëe4®óé t8Ą˝»? &f Hęćd>×Ç*ÂÝ+>nIĂiňŃ{Z*ę~Š ^1>ć\ŚŚ—Â4µ@[‰‰cI>¸čŽÂĐďŕ#ćÝWfQ#Sţ׼Ôs4FŚf„ŃNě†ń"´4÷h=B®_’?±Cédí~›I%Ć~’~šş–ëQ*÷ĽÚ¤ťLä[űÇ`ikĂŐeWű…–{ŹFm¨¸PTK]ŚR…ř¶żCń—ľí·ůOŃĚś§¨$I–;Ć:Đŕ{1 +”äŰ84ęőp“`ż&zÇ™Kjš—łD`Đ9SÔ° z¤9Tř„WФ×T §ßůŁd@((ű ˘XDÁŕc{cć儊|-Ą…v‘Á‹<{~|Ţ©—nĄ ?óĽ¤K§M‰šŠ”îłëÚíŹÓEľ’˘“­Sُ#iá‡!9Ň÷%?ľ3˘,éíÂăF]ňűšU¶'­k})ďÍffs^xYzHč›jű€Eź?‰b˛·Ç[|n›dú¨§ö«)vÚťg›ľ˙‚wEČš8çń¨(°&r»ŁY%ŘjĹ“MNóqö°G+,çGŰXM¤»á-ŻbgZŹ˙:;ëśý÷J ˘eďţ|mÍV=ü8çh@0{řtĘ•4Ů~ź@ĆŹ­ %gľśPžpVÜ-J îx˙Vßňb­nŤ€E–K=ůe¶ŮŤ¤$ËqvCśí(+Kz2}”4˛ëLG:Ž+4¬«ÝoC¤-ĺ‡őŹ5REŃ˝žâp9v%ž_¦§]ŘŹßý¸YĽîĄôםj3 vđ«zno XQTłf;ŹX­´bâ}6h<®’W¦S3x–*@fżńĎhŐˇl•jˇľ›{ő’TřRßoC0‡C>\¸ŠÝw«këźooÉęŹĹOńÝ>IJN´ĂŔýţŁ-0Ż– ĘÝC»˙ţG_¨öYz=ËE»_\A˛zz]Á­ďdďUřÇţĚiłoTŤyŻTô(˙(»#R‰­ĹWeŠ ˝ýföď M˛łł6öÝ^`r8ŚBwŤb›—ÂŰÁľż97¬Äľńîľü,»˝]¬6”<¸ëQk9a>X ^„e-±PrŚňřĘT0aŞÔÄšŹŘ`í¤@öu’KBpFWh_dDďs3cpę:PŞš2NÇ \‘^j`ĆvŘ÷A5§âÍY`«+e?ąŚĆ$Ŕ r—Ýźzś­‚¦ŚůżčŕÎA!S­0Żf.)G*ßi0ń¦‚GÓ2`F¤W(p„ DËj6´É}©ě¶Ő§zŃî9f›»uöqőY?jzGf2ř˙ŻŤsh΄pl۶=±í‰m۶mľ±m۶m›c÷˛‡­úţBźOµ; 6ěf1łů¦ŻQerlZée(…âwú–&*>€]1ć(Ýł{îÂ0!ś9IQĺĆtš%ŐěĚÓTł•(Ć / b‹rŘăŕݤn”+Ń˙ă.›E-űEvC$( IŢÎ,…SęÎ[ΆÓ*âđÝűđ7Ćť§i—ĂŔöEÍ˝0Ë(šß_>Đ X(z–„{1ĚNyÁ^—Çz'xö_Ďř•örV†Z¸śÄ?4~ŮNk訍’{o±ŇôCSřˇŐ «˙ZlăZv•űmďYb-@¤ćvm´»CKĆf%#LKhwĹ,43Ö,¬­rHĚô$‰¬ő^ĂżPÓ7Üč­—˘< ěűĘ&]ްeú&—ĺdçQŠM…ÁĂńGĎĂ"©żÓ„Ą0ŤîŞß“ʵcm*Ă ĐÓhţ,s-ŕß 9y˘ĘŹk6›<Ü-M'.kĂŘĚ ü¦NëŮ%ů‘1 “ ·†1[›Ę)ż™U óĺ°ż#ŢZŃŔ:bƲPmµwôŰI+ääÝJ`Ńx Nô@ČbÇßw#•´*jë5ëŤqŃ‘ŻĂ€/DÄ 2´‘4×7>N=´sc€ ÚołgŠUQâü!–íaSö+Rdˇ›A# ëçEˇ§BÄ÷˘É˙vžTNĂ"˙A…Ôę~ś™?ÖÓÇę˝[AS5#0ďuí’QWY­wůlóáč@‰çŹůĹ:U?.Ń„3˘ş·ůDä“-ÓżeĂ/ä›/ÜqĎÉyĄÔčů´÷©h‰nĚ×ÚHŹřĎSrX¤~ĄÎBlµvä,¤05zżęŐ¶i ÄK*ő`38bÝ \¦L‹ÇZ§śž6UĽÁĽ˝› Đß•rhuˇGő+›/Ář>zRZ%“b“śvËż±uZŕ’ĹĂ­yݱć5«>úĽbŃcÝIC%'ukV¤ţ¨05e·\'Z»ęŁßÁQĆe.źăŽ–0µŰŇĹ}@ Ń$QŁ\BEĘŠÇ(ŮsŻĹ [ ÷ŔÝiha˙•fžđÇ|%ż7|HpiMß„B¬c뛀¬Ő˙X:tő§Zkź ˛›U+­śâ…^ÓegZ4ä Éé1˘«NŠĄ­OV˝‰n”z±%M"qţ[gÎkťÜı@3/¶íĎ[ŁPöB/FˇŻđ1ĽZô¸ŰÝbw(ÜńUxBď!b§›¶ř‚ďlɤPę˛Ő`,BEE¬ŇýŻb:PŢ‹EgQÜÇw™:śýfs@„ mšdxúDŮuĹ‹WQĽßâI‘@}Ř ôR*§ä( Ž <(¬§â»đ˘ĎĄL'ÜÓ…sőĂ·‡ Řóö?f±ů[ä™ç5~‡Sh ´¦S&C e8OŮNĐ n|É_(/6ĽŹ—dĂür™úm¦­I€rĽý=8p‰ Qmz‹ é13íîËĐÔ)BŻÄĘŇćąĚyrééG0wu§_„ęŕ±f8ŚS;„ÓĚd őŕ,÷·űö fc° XS˙.ËŐE‘ßi {ˇýŘOp0Í˙,A¬qŽ‹P§HúC"ݢ[ÁÚ—đn’}Ä;#fýý'Ň7T¸Čł˘~ô]‚H÷ś‘"ͰBktRíě ţ•ÁQŢi˘úő Í""¶ŽĆ Ř źŰâe~Ľ=FÇ ’qw`şZŘs§la0ćź^ ™‚—eŹÎç€E‰ůÚşVc a9‡¶f(ý°ő,”ëîi™ŰĄ{ĂađŔČ9ĎÇ>«L7żZÚtS•c†vgýĆ~ű^(ѰRÝ6 Yű§ó¨Ž[,Ő×i şŮłs¶)LÜŰ"çĎŞB}ˇ’™ëuµ9î«GŢ‘A%m °\űńfZÖA”A˝ÎVgÂN˛;×NüIJ#N›´á‡}°Ř"Đ™/[5VbĂܡŹ$z Ľ­lcĐçÖtc¶‘$,ĹdŽ*ŢT Ę1-Ci!ŸzIÍŚ—á˙ĂÁ!çř[H۵śŁ•‰}Ł2)7ß=DŘŘoUI(Ë3±»Áź×R‹*}%y!;Żžčç™EµT>5Ş"ĺńĽN, Özy š¨ĆÝo®łgFIł‹ľíĘçž đ׍¤˝ŔŤiׇ&ł^V¦_ľŕoÝć®^†şÝ `Č÷ţ¶qůa9DŤožS)Á EčĺĐÁäŕB„»ůućÄ«L  ´%{ŠłÍ»/ňL>„Ş«KŇ×3ł0śdç9ęoĐ©Ç`bÚ-`nč—=Kă#SRĂŘDĄ ¦«D™¸«÷oŮQ,°-ôEË‘2±x˘lRÍC¨ŤŐůČ÷šOŻó_ź›H6Ł} gBl"e-šż^ŤRŤQwĎŞá÷náž?t”ĄYn©ćR–¸ŮQĽÝf–i9*Ó•‹kއšşž4  ĆÔÓ§UâRlúof“Yň÷‚<Pw~ϖdŽ3<á Úĺ«Ű¬¨ËÔKŢ6ZZ~öH†×šÇŔ±T¨@E«Ö´źęĐŕŃěĄďiVďóTZpµÉmý9‚—˙rä*\¤ÜoI}öÜë—z6h¨ĆĐoŃAÎň8źË~kŔY`ś¸ŻeŮë+ĽUÔ,ŤŠaů‹&Ô\–Ś{łEwľ°ß$ĎúŘ8¦w/š4D&pź=-útEŽĂ+Ë Ěť3,_zóĺ8·[-9 [ňłŤ»Ţ'Âu×7Ť¤Ž‡ňČXém;?Ś#ş°‚[©-'z!€®7Ě™\ Q2ĎŢÖh ů{ă™Ůěq´ĂóąŻsoi»Ů)_^T‹ çŃŔ·ďűŁçë„úžI¬j˘äâě~őý®©™¸Šz?Oť ú6Ś0ě4ÖČ/™ü˘î÷Ł!gó!OIő$Ąę>w·;2ú'ć#ëľ('°đúöLüg§á2ŮPëó{ 8őůŘl L7!ĎŘG ŠśIÁôrdŻ Š•¶§ś"5ž-‹P‹´F<ÔW”F˝?¦íd—Ł–˛T|ŮĐÍŞHŹťÄág•x÷:ŠÖĽ»é śscŤ|˝np8‹m&»v}%C¦4I2uŞC·ş7ÜŁďRż?(stý$Őäł,ŰLňá,!ą‹Ěz–á‹x01\ĺ˝;€…ś…ŤĂRň{đ|Ć]żá6á†L›s G§–ś¦LÁŢŁU ňŢ=XÝr,;Aôˇ—+Š+fą?+]'!$mâýđ¦Ęoď˛ÔřŞ<ˇK‡Ďîő¸Ů¶˝S¸ĂsŠâHÚxłŐ$t‘d‘HÔŘf\'“ÂJŁçڇwi«ÁĎ(•[ŔľĐ —÷u Oę?X<1UŹIE6Óˇ2Ć» °% _˛ń^‰ aÂŹ°¬C;ť$Îô•R§ëť}Ťűm[&Ôň¸ćU[´D†§91G†nxšîüÇŘ(ëó^ů}´ř! ŻN"Äp9űąí·’őÔ1˛”ď§+b—í4tÔßąÁĂöůĆG›ĆF1ýZqx, +L‚“ö -'¤ĂŇŹäËđV]ŐÜBLř(ď9Ňôěî|ť¬óf–zľâĄÖřF™6:qžZ¦Ł€ÇÁaFĐ6…˝2vCZÄÝŹRęđuť¦0šŁńAg‰›gtíŇ”i@ň-ĆňŹő617óóŁ”}ó8ŕ–c ]&ôÝ6ŁďĽÓ|ľŐŕ‚ zY'Ĺž˘ć9$űEgZ)’Ŕâ2xY‰ÝŤĺÁçÜÉ?¸×ě^hơ7Ź(,qdňä…ú"˝Ř'łÉ_¤üňň$‡ę­6 ‚ŞŮťTPŰéhm ;cŤň˝×ć:ë{—Š;[l:r Ĺöők(—Cëbţ[1|Ëč=ľŤ1•G ‘'G‘ !䊟+]iŔz^2®Ďţ…íć8€Ď§#6穦Ďĺ%óxáß vކ^w}Eě±´Éâ¬)¶öFé—(lŕââ·HY:YĂń"ŘÚ¶Đ|Ń+Ë‚Đ8ŰËĆ呦RŃ–‚ĆÇů¸Ű­16‚k¤űóg.¸ŤJnÂ}Ű—CNç7v]ź Šú!‚™şÍžęŻ9)nž¨śđOCĐ­†ćWÉ3"”µ7^e ő_Uܰ´şŚˇĘgÍ›…Ĺ #‹3űÁEśL/P:iµłň÷Á3>O•ÂÖÝĂKtËË\´Ę1.wë ÇPşaŘŞ#Uµdq7ďť(é/®Ôčp××Ř\ĚÄÜ0 öýçVW<°gÂnů)ŔŁ˘?FmrIéţ¶óÖ3°˝‰8Í:2¤B㳟űlz§/ŇŐ2Y0 ´BĄóXY›đ82pĂź1s7Śš¤ü ~}7żž Á>~ÔÎE%¶dugî 8)LîjZťńs Y‘GÁż® ;g›QÓ'VQŮaŘl `­G°|…g~v`s)bńdéËédO•Čű°™'uS‚ş¬J^™ä"Í{Í#n{q‡GVaÓ˙ď?đđčńhqŻUMC!ą€ďü٢îőh˘ů;µ* Ń1uu»üăńűq4RJ ö×o,;¸wž.ÉĽ–‘ľE2󣶶ËóX_áY]*ŞĹ¬R:Ú}Ʊ‰Ż ‹jtű‰&_ZR~›“@˝Čš$ µČĄĎ^Ĺ‚üŔ´ńÓ­něÜfźÉK˙«†Ň“űVÍȦ ¤ŔIŤ‘í¦IčaôzPęč»…ťJ„G/A€€ŐÁĂR/ď5śřsď;ä~ÄzsŔL@›(2†|Hnůˇ‰Ř î™uŃë#ź´Ă‡#>–n…ózَ g0 gż˝}áĚďĎĐ(uČTq^6–Ĺ"Đ“\u›–š2vű -?૳°Ô'şĽő[,ĆŠ­ľ. Ę^GěÇRy!jaPť­N-ĘŇ *‹“&Ě˙FdńÁ3Qún˛WŔěkZj[! Č m WěŮ\&Őř¨ôić˝*F ŰňÔýlQ ČJŤ¤r3;BŠÖDťü÷eţZ6ÜͧćE{ ë…F>çČWűÁ#«2|!ä)!é硂_ü|ë=*“hŃ9`V„·źKřĺűs(Ĺć\«Ss ~Ěo]ăI§k‘®â>'M†Żľńmą\Ľ’cIđóiVˇ%NłŽläBÎ|ŻÂŻLÁ†4Ĺ`őA1+fp–»JĘUů݆—ôu«ZĄ°üË]5pŕâ"M™éÁG7n„ $„°ů@#Š@ˇlşd‘RžăC®1óŠĘiP’đĂľVAQ§yĽßÍ'0-đ·;“z0)±Č›”#Ď˝’vpĘĄŘE<1ümÂËCj8^Ýý¬c†ŰVŚńQ‚(ňô:K1‡_E¸XĄUĘćÝťżUbHśřšQäî€.{útŻ Q‡­"ÓYxľÓ<¶ŽY®'üĂČ®I±KýĹ ţd@”$Ţ‚tĄ=&˝ŠŔŽäVKc¬©ĄŘ* ±°T_38‡·<ˇ}—čËőqĎ6›Ž2ÜÔ6fĐ =ô+ŁfY\->fYűOŃ|{Ôφ",á7V_¬ŠKźu.j‰âMH˙łyÚ­%˛Ŕ‡żf´ÓîHµĎ \{î%ÓĽc©çͬOj3Z/W?Ő$+„/;’ů†ű~Ě˝›v )ň1¸Ťé­đף¶=/}¬z [í[˛Č€hĚ€Ú G𼏺Cß‚÷N ݧÍ˰×~Z"w?¸·=FíNúúö¦ş·© ”g4ZĄ“Nř ž?*ëZĆć4“ĎIę{oŇ!MÎNÚYE™«’ůŽŞ1o2Ąň´./6EEŻŽ5 áâ6š«ČÝĘĘĽ Şˇ2*O>|4ȧÉcű$  [Ćmě/îÂH<ť˝đWŐgţĂ:Ľ‚® ľŔxĂ"ďÖP!U Ú×ĎHÓzůDÉÚ¬›ł~:Ír}©űň:Ic7kÓ“÷9µ;Ż\ix¨Ä†PßL(:$×ךŞę𥎿ś©8•y­ťËbGď(LLPą~7ą{“Śąü·1Ô>ć¸Z_q‰čź HŤ˝÷¦$?¶ôĽ\ľvhh l4đŚ-úvůÇS©#żůYů(ćţ‡’4Ó–ĄăRf{ľĺ6¸7ÔV|@ŤcüţÄVşštčCąĺ‹÷[ŚM%“Ős“HŇŇBH·…¨ [§ĘĂđ«.NfŹ„¨µĎtT6D•×jnîX>hhdqs ¸Ţ«ŮÜn_R%?(ĚtÉa_Ö¶ÔÓ¬V‡řE‚“ČsębÖČŻAWHٵŠyA‘·îC˝×; 5óĺfJČ“Ç ë' •¨“0×ě÷vŮéőÎĐč5ęííëgi±yb¬t2@ʍÇń`ÇzĄ«4 +Öř›řĽ]" R,–_MË·ĽůXě»&}U“*Đ€Áýś™réEBíŇÖÖ­TîáâTĺz‚noÝKó‰FÂل–ü¶—÷x‘9’ŢŽđeai;‡J¬MĹXÝú>䄼üŤ űÍ"Ş’9éô Yü>´jhśţ†R$qEAóÁ"•Ľë ŞL &ç ˘± NZh)Ű,üĘr, + Ü"ď׺$Ű×7´<‚mE–čÇzMŠ:ťvFţČŻ©ŤĺTŤµ˝Ęd¬qFŐ”Fć`Č `|@Ä”cr´–©‚EßZň®ĺ=Y+Őc˘î±ęm˝óôđ†EŢ5R.ś/tÖ‚ĚUö'Ţť[/ĄÉŮ_ŞŚY)°˛ŃőřěÝ‘đ4_h®zçľ#Ĺä‡ĚAˇjX¬ç­žřÔë8¨\Aóo´ŕËPOYr›:Mk(T㬠Ću)µĺMłX7wěőíĐŽĘÚq9~;ó/ëśL€A˝ ”ţćkJW>ł9a·µ^|ĺ'&µN@‘1*'9ęVOȰ/‰A˛ËhT;¤fI"ŹUíľeşĽc&¸ŮÓŞx§˛($přÎĎUo¶•¸R źęş˙TıžfŹžQ­zÜxë”Mtq_ Iölî {—Řčf |椵E/Ž"ĺň)iWPšC\ű¸D Ŭë/‘.2wP ÍA_é~ĺJŔőM˘Ă\@ĹąĄîˇhé¦ů‰ń—VJy)śî<}¬Őr7`S+ńäQ”éˇĂDäÝĄ/¦ 'ëšý˛Ŕ‰~‡żŐë# ;–•ŚúđÄ›žvĽ'2€©˘&ŔřŃ JZî!ŁS­ĎŚVPĘ»îA·/-ň‘<Ňóŕ ­ő‡SuŇKŇ÷ě–Ď‘ŤOŁwdâďŽ+˘ĐâN—8q &.»<ΰÓTPĎŔďnbÔ6,Ý*ĺŽ?“©N›Úŕř†††WQĽü‹T<ş^#®ĎPÍÂíşGĄ™Đ˝âf/é59]Byçőô¤‹¬*Ą Ő†r+›*žbÄź%@[Ĺ­„\ě1ąÔ¸˝qügáţ šl&Ń5®X$IeÚwłś|¦rą”»ö ™%{…#CÜĂ—1˘F¬ Ë_T”E'߸Ů«'Ú/űčxŽ‚ŐîŰCLĎBwšűĎÚż Ŕ,¸ś+Ó~-¶—N’AşŘOĺl×g ,dî páĐ8 ĂiNBŁ1/v´yŃ.t_öu */{şđ]ů4ˇ+µd^´ËćmĆ×YţŹźÄ7ÍÎWň –Ď›Š¨Š)“”!Őź«++‚‰ŮŐ°ň÷1Xg§Űc˝‚ęK'ľŹŘ}˙36Óüpg~‡2(ŚĺS씋ńk1ŕ&$ůTÓř×Î@UFˇ“˛kc_} PÜzZ#Ç—•VTűˇOť ęCkęŇËí8Ľ2 ä0ořŃmÜ˙,ŠűڱëÉ‚ÉécÍmé~}*ZşúŻŹ•ˇ®©ż©Ť×ç]ďÁ´ĺ&![pÄĐRĎ0›Zˇżoń˙"•“CyéżâGT •ldĹaČĹĎŇ'éź»eë„AKQ‘,Í™ů!0ä9Ń0!Nŕ‚˝Ë“E ¬źě¨tîýC;ú¸¸ú·Ąäoę`îcŔŹSÍMć ‰Z!¸‰ŰtôÝqŁf±~f± ż˝DÍRâQź6­u÷Bćlj˙X©=[âW±üľ˛Mßň$ęĚ!Ę·á«(ÔťRrt`]ÉDHCÇŇ—Đ‹Řńy˙öÖ댣ťÄ›;W†[ŐŕkuIߣ$č­á•jć"őr1ĂsٲDóli?<ŃÉaeĘ2 ëŔÝIqŠęĽĚAĚ̱ޥÚ}ĐH>ąýřj=˝ŘđÁ ‡u©CégrˇAŰ 9XÔ?JdŹ_)_;żś<5 ď«ř)]y«.Ă˝ ÜHsŞ^BKŮDđó0­ß4Ў^ťxĎSÔ|ˇô˘/ŮřۤǦČSĚ•˝¬;k‚t/‚ľ¬ĚíłĂöĹ­3đdÉ7 ĺÄ+«OĎQ~M>|äďń}u2Áôł•Ç«2eľ^o'| ¶`öAH[4Ź|ŁĆ˙&L9Pą(ŚškiIŁÜţť+ Ť­ö/Şďą×žÝw7o5'äecĂ{Üĺ¨?ýK`¤ĹLĽšŠ§<°móK‘#ÂŮp‚z$/Ô˝‰e/ćáĂÓOő•ř '"F:ö4.u”±ĹÓ™4ń!^%. î–©đ&N:g®˘Ln1—Ý»MOá'Ţ©ŃÂť< ŃH‡đxn÷¦¦{ŚpŹĹŔƮކ†­¸K‰Vl(4 ’™ť‡÷h5ŕŇ5=íä§“ůÔTáyŐ&ĆąŠČYüqBąL~JÚX ÚjJÖ_M¨Ů.ęETM-wň&äe›‚”;’·]ńć «x§MČL‚׌%qľ€ë—ĆëÇ 2-ŤŢ’ÉäŚP~?«ĺ’ňfđ{lIČ*ź\n:;dJĚü(žUő+×Ř3– TĎ#’˘Ü—_úĽŔ ˇ‚zó´v"Ĺ_gĂMö\ťwY€Ó7›^Ţ:ŢPţ!ÝĹĚĆ™Q=°«éi,]5TşC×ŃfÂţ+l‹h‰âyéÉký…çf;´NŽÁ®”`śC[ďa' ˛v BWżĘË6µpz üRâ¤`cŚÖ >µL!˛[n_”±;ʬ=ŰĎÔÍUÄR#PsD&hľN·Îý|źŕŠqĹvŹ­Ď2 #)í†j{ÜR|ôQ‚źqÚj×Búf˝`ŮJC.Á‹é*k:cKŁÇŽ«‘,]đ ”evČť*wPâýťŇa.Cí\ňxŇ“7CËäI˘d®qjĺô4‘[Řd“ő!ÂýŕnłQéď|ůÇ‹Ź:Á Ľ”á§#ݳijsÂŔŮ×n>(ćuřH^l˝×Ĺ·Ĺť%Ćj¸ZŽfę«ľŽ”j $<圥W°|Q«Vź Ű]«GýͰeL”vÁ(‚9, t×­ Ŕâ1’–É"ŰUTzƉ3“…Ăyť;7ćxH/ ⳪oyćŇ D'š*ĐH¶¦ŤNy8jÝ´jďĽX×H¤NĽnî­®l!žS<¬\(Ę6XĄ€¸béôĎÉ–¶äů¦ü˛^˛r1Ü/]h°28ęÖ4 q˙:sOѱ˘(űI†00Cb9ťĚâüá.t ‚'Fh,ęř‚ÜĂ~ł^ņoŐ×ÜîětQŕ9™Ď9vöĆś~Č=<ÇY’ŻÓ€3T3­¸µT×(ĺ%ś5É"Ń–(łCÉ({_58;ÝŐ‡µ<î O:ńyŔĽÍ8…®7Ü)xë¨P˝nĚďŇËP hŞŃÜXMp| DÝśĂ)řTľS°Ý°=a C/6ełJÖć#îő^\ŠäÖČpťřDť-o»’0>׿5€ŔŽĆ‘c¨ám§žŐĆŃN±w#z|^–UĹ[‹2ÂŕöÖ ľŠ}¦Íí!‘΀)˘Č«ť?zŘßłQÄ•×틞mŮú@jp©KfĄ¨ÂxicëĘŮ_ȬÂ\‘í;!˝ÎęůL °ÓY˘"·:ęF&Î=­EŘFx®¤·fŮWOƨIZInŮ(x¤:ŕµcăuĽmý°ńÖmÖŚíw j߼x¸ž˛yŞťĹyž'PkqcđÇkA¬ř%‰e¨ŇN‘ŽÚ†z4düˇAuÔ~5â‚I8tô5µK—­]9Gçďq”5’Ě®*Ă ë±ÂAŢßNč›<çč#÷~3Éô%-=Lö ól1fůhop#™´M ;Ř249óÓ™Ç;Q(ßÁY™Şb Ř–š)I ńPh-yŞ{’üIJH±`°âÝh棙ÂoŚ`p SCf™ •úň˝míQY˘’)<hŇěú­áU§-jc+:ŻŚ\WŚýťťaĂo PE˙üDźEńřř(ÜŞYĆ·đÂ#Ą}ČFĽH쑚ĺËĄŞÓ˙{¨­íˇŁç„ĎĚź˙ídiµ´4s’ÓĚAgIriĽrPŔł´żĘFqŻđ‡…,e˛‘G 3¬7V€E®Đuá'Ů•ěćÓ}Tž™Rjz ť3wJâüß|âŢHˇ÷ k Ďś&Yĺî!¤fh6ЎxÁˇËć)8›Ł®dç‡&f<ÚżecŕőTĆ7p;JhA·o|_`{lćä=—ŕÇP[‚˝ö)0ۨóLplWbŚ&USCzxşÎÓÝ[)żŃ›k|7Q‡03MČu-Ů…;Í 7ŞŽÚś3uŽ˝@Q«?˙z/\…~ ÂDCfÜ·uHŁÖmMó«ąs䋰;Ěăş´ĚM ‘hXĐb¨CŚęŻr˙Ľ[>r*$<4ű6Ç 8“ý\ @·Ç†'dH…|xDŐ}‚0¸®ř’ˇĺÎo¬†ŠčÜdîôÇlřân#ôŞ˘©µŻj¶w§ß‰~@$VNTŠŔ`Çö‘{í -5I[C`Č)«×ŢăVýIhCőęĄOf§˙í0e7EŠçbu1ŞťxĚ˙0ěĄ"™xŐť;ÔšfęÄřţOP´ endstream endobj 257 0 obj << /Length1 2768 /Length2 28892 /Length3 0 /Length 30426 /Filter /FlateDecode >> stream xÚ´ąuX•Ýş=Lt— ‹înPşĄ»{Ńąčî”–î–îî.éi¤C:Dř–ď>gëŢç÷ďwqăÎ1ÇĽç3€’TQ…QŘÔŢ(aoçĚČĘÄ•“ł·łgeaTš»ŘlL,,””˘  ‘łĄ˝ť‘3ŔílP0q§‚#XXx)’@; ě4{ä€ÎFŞ@VŤŃ?@ŃŢÉ™ŃŘČ ěÚ™[ÚiÁ)˘ö Ks çß5ŘWúť-Â12±¶ws˛¶Ů™däňön`Ł%€ĆŢ` ´0˛1Ř›Tš5qe€¤˛‚š˘ -¸°Š‹=踪¨ŞI2Ä„ĺUĹ@u€¤šŠęﯪ@;0s€Ľ*Ř˙»8đwşś¸Ş°Ş–˘8+óď5X®@“ĺď¶˙ĹŤ Ě đ‡8Ő doűOŤ…łł3ł››“ą‹“3“=ČśÉÁć~Ş–N7{5ü´ţ#Ś‹ť)XNg ŕż üŢ€¬Ą ĐÎ ř;IÂţ_N[°”ŕ$°ÝůßÄŔB8˙®ióŻp€řm,ŚśţÉ•UT”ŘYÚ9íŚěLŔÎFÎ.NĂlŕO )őż˘. Đďr˙ëý»Í˙R±ŻL×ĆËÇČíżwĚČÎĹÉó/mţsŮ&övN–NÎN˙ŞYÚłwú˝g–v˙Řä„ĺĄ%ÄUTeÁgÇ(gVÇŽÉŮÝůźčßő„ĹdÁŁČÍ`cc°€‡TÜÎTÔŢÖĚÚ ń·|b–`ťśíAĚ˙g®­íěÝěĽţŻÝĚŇÎÔě·ň¦.Ějv–Ž.@i±˙‰›˙ŘĚÎĐt7±`ţÝîźiůmfýmËŕăĺ`ď03˛qúXšÁß˝śŚ\g ĐÇëoÇ"DVn€©Ą‰3xĐÁ‡ńźęŇvföŢ™ÁLţ×ő?#@óĎAĄźRS{;€)Đ ‘YŢŢ<4˙˙śł˙ę%ábc#od ¤ůoI˙;ÎČÖŇĆă?"˙+Bř›+ŤĽ=ČÖČćż|–N–î@SEKg‹Tü—YÚŮ<úÂvć6@đžücRű}šlŔc ~ôXţ~rYą¸˙ËžHk; “€‹÷¬ÂńK˙›-€YSS[TF„ţ˙ŚĚ?aâv&ö¦–vć6N.€däČž6NN€+x¤Mî˙ €™ÉÎŢśppqöŮo&'€Yř·é_Ŕ,úńĹ˙Ť¸YĚ€Yęb0K˙A\fŮ?\Sîâ0Ë˙Aŕ ˙F<੸ňî ňqU˙ đÔţ pÍ?ÜAëßĚĹčG˙±˛[ŚLŔŹE3çżĚś˙cţ×$˙;™ő_fk óÄó˛˙Űţ_ `&&˙FśŕŢ&ö6ŕéř_ Ço‹­í~¬,`AL˙‚ŕ–Ŕ?Ŕ*˙Ł×ożŁ‹‘Í_)`Íţ¤€ą™YşţUă·ŰŢôW8ÄüOE°ßü÷ ü;LÔâm°<@»ż"Ŕ6Ëż Xuëż xé(r×hóű üń…˛ýYÁjs‚kŮĐ_~đŞí˙Đ'Ű˙‡Ľ‡?np1#đőň{ĆÁú?Ö˙Ü1vp/ čź ďߡ\˙Ř,í˙ě X2—żVŔ ¶8ţ)ÖËŃĹ|Ă˙µ3¬`ë_˘˛‚%űSó7şţĄ)'8ÜÉŇýOS07'#'‹żJ€©ý!Ę ^“łř×f×îěf˙W¸†Ëźů÷üçMŔÉÄô·€ŕírý ‚vűët€‹ş˙Á]=ţ‚`ń=˙pWň‚ţĹŕ?vŠżďú®1–?Oż˙y ú«8ě­–¦ŕŔżBäŚŔ§Ě]‡|±‚íŕŹ˙ýIď?Pţą>˙ʱw÷bäKĹČVŹ›ťő÷!ăňůŹT“˝ŽüsýźŇ˙‹ż €@w  âʢ˝ °UJSh©ŻxÁt,%/Ói®€¦L<ĚJútÇ[|±Ü2 `a@‹Uˇ˝¬źžoR€]±&e0ŽÍËFkbĺÔŤ©’Đ®‘Żśď[TqáŻ9ęLjrËţe]d´G29ůZ_8f3ÚâŰŢÔľ‹ňvt?FłMľb\%“é–µ}Ëu+šgmĆŮ`ş/Łvľ]žî„t~}ÄŽŤ2ę^ˇ›3ĚĹý*çĐŰŤ®Mź’ŻŞyÜă•ÚrY>ún>bS›1“ý}QµP¶ňůŰ"ătâťOŮ8Nů‘–6Ö©Ó†˛ËUĐĚŁ^e$*‰ŤT«JŤĘĆ*ďPµEýô!Žš‚Ît­HmJ{ý­Ž­Ůu§ß‡}ĺÄĐŁ©VîN2đăHíSĘéÎ µňî)çâ}- "Ě©Ć'rćžeŐÉŤb$›\ňŻIˇéV|ž—ĎzŞ—”h)%1"ô$rÚËr0j ¨/A°ĺ‚§2>nGÁÜ$äG5Ę1:ZĘÖşżdš#…^@,ĐM"éŮá][!Ş•óca®@ŘPĄ3{»íş¤‰{%Ľíßz–»Îčö´‚šýŞY‹!‚‡:¶oN##:x(ý°6TLúÁ»vđDĽď™ŐŽż˙züjţ˘TA6;ćiďFp±Ý1ÂZ’7üa@ýPß‘ŔögaMĄ¦üKH±u¶ś+)<dĂôž"{Tś[±€:®`ˇö­)Š©¨Čfű+–Sldn‰zvż0Ú'Ć"Đš¦ÚhąÍzřçLŇéŐíCţ˘°ł ‰_Ă…[·“XeŁórDZQĄzµm7(TʆĽlL|e"["q{|SĂ‚ąłeN”bÜŹ“é?J]wi ¶é!Ö×Ć|Ňçxr KßOóĹ,ŞyÔZĂ{ř#¶!\ÉŕMPé«÷1^3›»Š™+ú™ĽYŔ­cĆh® cÜĂ Çíđ ŻI”ZLď©í®¶D«ű~O)Uxh…K;NR(4xű Ą˙Kś]„v35!z®ĂśřC¤jћ՛D¨o­Ľ RWzZ&?|\űfřŠK¶h¶Ĺ©·MČ$]ŽŢ‚Ş˘: ëžSyüúěĹË3¤Ôóšłő*źđĽMĘČňcŮ f®×†ŁóŻ˝ŃIÍj±dó()—Ç$Yu'LQ_Ťľµ˘y«óS:6!2Ż::ęU®sżPUKgöĐÂ<µ3§Ö|DŇ1Ĺc‰«Ĺ@ѨnF†Ë°Ł(Řń”žŚ:úüJ ¸Aá)LI×F”É·'xŕ"Ťh K Ťś·ŢáË ú@§ě×›šTęëŮ‚üö)uĄczíבě!l}?ץˇ$üzŮ06ëćÁ ­‡đF,zßňŐég27  ü’Ŕ¬¬ďş˙<\Łč»3˛úd[Ծ÷fĄ¶OÉ©é3Áľ­hÁîâĄů\Wä××Ä'5ÝůĹ`9•÷2_Š8RJî3=KĽŕ(n=ĐN>gŔ’˙ěřě8ł:á‡iŐŔČú@fT–!čDk™4ťÚŻŻÖ]S;ëfniĺ¸ŮżtQpg;g* Ov7c+ß1ZcĹ$(đüŇqéqŞ0ŮíŰÁĎRy‚_“>ŚĎŞo8¶ń‘ź#^˘ ·• â’Rˇíű^÷DŃB!ŞŇS1ňudf`'DýŹÚ=ŁG›~y_†÷SáEx/ö™úáÖíťBŞlĘ)+» ŮÝí‘>vĚěŹyˇ ‰/M§łM—Ó•_¦qxřľâv×-!6ë JĂ‘ĺflŤd ŘÜî÷ŇwţˇnĄµIYIa&›D¬ş»sš"輅˘˝sN<ÎŇT=ą3¤Fą›Â$bÓňEŻv†şˇĘ)mK·ůWüçž’t˛Č™ŔÖ>Ç˙ ©˙P2±¬¬Â¬đ ȇµäčDwŞ˘ŤR둬¤ŹMaÓäňěaĂo7›h…Đű™P0żŤÂN’¨#DÂńÇáĹ‚=tRĐ–šôó:ëe7Śäk\W%Ýl×Ńä0ožźŇ•ţ‡]?ŽDşŮ¦˛Ť‹ž¦™{ZV÷]ˇÜşŢ­IšËâ·–hH۰ąZVřNE ~‡Ożl8Ł<Ý€0ďʶjěîťMá37DË»0MęĎ/ˇCůÖ{ťL2¸Ę¬©u[ú#ÎY$Ęđ¤âŃÄüf{[ŰĆ” äĆ:h¤¶¶˛M´HÄ+Í_¸•.óQ*SďˇI’řVŇ.ƲľG‰şjó3ľĽ””IĎĐŽ"Â6 0öć2ĺî:>űňâyâ‡do`ç\˙đŇ:+âbŘď€ÎKȧ@&[űZFFőÔ._z‚ý¦±(ßý×®¬Š×•´•&łŇV0”Îj-QËÚrUcs˛AôĹ‘md†pŁzKŰoŢ#yĺZHľÄ޵¬ńp‹j‘ŃkőkĎúśl¨X@/gĘň»Â)ĐśpJ.őÂ6(±÷öĂĚ®3!żř-«‚idő4ĘţŰ»x#ĺGžŚĆÜľ7&Ř;‹˝x|FwČ`ł5Ş­‡ű‹iñuG×7o@µš…ą43̱Áeäxź ÷bÖĽt;Ż $DzuO?EP§ŰQ-%S˛2g8˛¦’jN)™=!Cg·oa8k{&¸? NŁÁJB˝ş6T¬šémjr6iş}WV÷Ł­/5ÉWt ™G?xĺ$C[Lţe  6>´Č±röŢk:MNW"ăŐhĄäó*¤ŰXłWmĐ­x,˝±?úĹŻ±>»¤ŢěÂb91ťÓa>ˇN+§™ÍÓä–†(µĹéÖ‰JK´×b×›<_e.EHţPů€ĚC‚«yĐ‘ÉŔ3¤Ŕé Ŕ»Ś!ŕ,PŻďŕ|Fľ»Ů¦RŃ/Ĺś(Ë{Ó Vťőá}ž#Bm®ĎzÓíá5?Ç_b”–i^Ďĺ2#Öj´ĺŤźd(ßĘöée˘79‰!Ç5"íÁç~Úôw˝BNĄm?!˛S¨IÓÉś¬.ĺDďjé/1‘ Ţt?s ťofş HČe}ł4ńŞo`gH`ĘtއżŤ˘Śě8OľHŐ-ŞA| ¦ů”ŰĹč˝őB>CPYĹyćܸGP丝 đ íbg™ Ô?×-vć]}|Ţ80Ť›Ž'Ă7 ¸šŽÓ™•¦Ń|óŢôűă÷J”$Ů]á5/q}™Ď^pvqăF“7EňĆč>t«DB:™ ĂËv‹ŮŤôŁ0ťĐňű-xśĺ,űjÖه śŮB"íüT& ¦ ęű{/Ş€ęé¨Ô‚›8(@ů~n붸ŕچ2=śtť°©ÜĚ­Ż®,ˇ5=‘y2r×XËş’’ţC˛»Ź;§'ż¨ľhjdąA§í@¸’#!ťĎ ń¦2-|7“–&Őńň¶L~dź9c—#‹ˇ_#7>ĹËÄ0ÁçF•L1g’\őn(_i@ďş“lŔ4JxŃBšÇÜŠwćŐÍ)#S”—Q€”=wĘÚHlŘĺÖŠęMýž”öná-Ú$Î ľ.¶ ?ĄTdd…Zűs‚{É™•Hß`]ôžhËY•§ů˘ý÷|Qöź›śmp‡Ĺ]Ř8×ä¶š>Nă)1áçąc7JNńÁÍńkúT1dVťRb’q_ŢÄ™š°őnÎŇËŠH„Vt›ŁiD˛Ó1† /EÜ íQűß“¦FÄżeżYţşíšžŮą1j¦Ó=BĽöł­Wő©¨OI—ĚŚľM®;jDG˝8÷xąő­÷®÷“ň¦_ňvg­šÔز‡ ię\ˇş˘Ţ‰ťzoE /[,„őLaYÍoëuZÔ­ď¬VËC۬éĺi®‡ÔĚúÎś1Ôq&ľ˘.ú…ĺGl‹J‘*Ž“gÝG”h˝f ű!UÚłź|łWčxĄ >éf¨ĆU˝«­Çu¸–ĽžšU«ŤµÓtŃÝÇÍ^„kS¤(ă®übj{›ýćlQĹ\rz-ßćĄČ@}2ü ‰šB‘ŘADôđcÇNĆfaXâ7jn>ÇGĽĹýąŃ]ŔZˇA˛÷Ůî«¶˛#­ĄŹÔł±řú…í~LIIąË ´Ş}üÂĎ/2,ĚL »–w“AĽ®©oţ˛ż]ťČQ_ŽŘö˛QlÜĚÁä#suŁKJľ—Ů3űhŤ îy†ćlTăm{oň‘#UđäőµÝŮB@ý˛]ôĽNůy™R-.jă:ĘRuxOÂÓÉŘ”ÔÇ]3uÁB~Š9¶Ůs†”iowĐÂŘĎĄ}ĺ;¤ďć­0uĉé#íÂÄsĹÝç  ~ĘĎĘÎ&‰0…Ά’ń‡šĐXĐOČźQ›gßµşŞ•WJô.¸Í Sy]lç'şxł™XĽMą˘Ň¸R-Ő„ršŇO‡ŰďMÁžG’„-i÷G&đm†5ëGm8ďz§7_ë)ŇZ# G°P9(¬ü҆ÓŇ:Hé@ÍÍíQȸ+®Y2«ńşíŠ$ň†Ą— !sä˘Y‚ŻË¨ůü9ľCŁď¤ŚuĐĎżŻoČYÍfĆTź’ťĄŮFŇŹáÖĂÓTŐE’KŤ-7@˝:“}î2Q̡/ĄVK$™cĎŐ<˙ć[˘ĽSNä€Űţ8§jÓý‡Ŕą×~{‹Ąłgô zž dl™şŠôh^ZłŠEĚ|ç>©×ě/4:ĸ…¬ĹJ[5%jVéiIqřôµa:VµyhXŞ(ÁöŢ€ÄřĄ´”oĄN~«”%Žď•Ó˝űpţ]Š˝qXĘó‡łT—ťŠC¦dvĂË´‰ >óĹĺ|ľ•ńI5ÉŮ®•Ćîmtső= ?…˘6RŔęôŐkUzQ›őGPŞĎy–l×Ţ7rŰ ‡wă4kjEé ‹7fЦZď¬D-ŮĚĂ{XĄu¶OĚ]ôď>¸y“qlî;ď÷Š`jS©–ŕű=Q`Ë<3{˘¶ŕ’)ľ1“˙đ‰ĆE©*,«ÝŻ‘™˛¨hłPŻć×c«Â›ýě.¸pi$> 0đkď JëfŮË-Ďűĺ70hŘÔmr”(łhŁ5yĆ©g8V,MĎäáJĂ&FüjI~Ś}+ĆĐFÓÔpT˙ř~§Ŕ·ÎĆů¦đQ ÄÁMëé®ĺÁE!WaÇäh醕Ǩa™®'„yU»ö~m"{¶*dť)Ţ;fA@¦}4) ±› ›!nŁđ”Ëô_őQ㏦ˇâÓĂĘžĽBÂzGŻŠédC áěĆľšh j Ó.Cˇ8ö:đrü€7…ĐňLÎ]|Ĺ<‰‹JĽJ_ 0lÂĂ­ű~âJ‹ý.Áx !Ą%™„+üZhÓM–”¨¸ÚJsF®5Iú€ţX{v›áËňפŹŃČł 3*xNáT»Ŕc&MÖ}ăÝÇŃŮ79öK—V˘0\/hŻĐD;oXúśŽő\~d)˝cÉŽ:…$ëxqÇHĘ«-&ąH oTi™É¸K˛ÜĎËa6ľ>.»Â­Fé«a¦ĺhőmÇ*éĘ·>ą€×Fđ]GĚł¨A{Ź1™X㸽ńN´ŕ–Ë•˛1AAĹá¨WŃ,śd”Páî˛ĘYeĹ„µO˝í·ď;»d̤ÍIvŢrĐđýóÎŘ…;§oŁpĂ[On凴ý”¨3©0†QCÚ?pó9YŚ #R˘bšhr‚“_Ż^ôôfúźý…˘] aŽ^Ő.¸3óQŇN™"ó$¸ŕe—ű÷s´)É­îu«(ô8úď¸ ;¶ŹČ°Ŕ'­Ę†C¶UT©;±A)›·€LɸY–H Ö„Ć‚OĽÇ&'ßD 5[Ě­Ub7fľ‡Ą×­D–%…0Z śĎ‚`ÍŞűÄŻ˝ÂsAş6ý°q_ˇ Qę2ÇŠP. o?t±«w‰†HôütĆ‚ŢCbÝb>—KŠy¶\0 BaoúđdĂÚ]»~_gś˝ÚLb)0ÂVfë÷XPIdXrR‚B…ń•ßęě)Ą~}ŕf”¦pB?t:ŕő§¬őPÂR‚rě˙2#6GąPŢńճł÷“E©ŢB^†ýýëÁ÷»„ĆśÎÄÚÁńy€ "ŇĆ ·‡Ş‹ Gi®Â~¤¨W\‹›äĺw±¦Đś,ĐmÁ(véhµźgIPpżXq #ădf?ţĽ¬VpÚłs?áU2ůĘ.ť;ÝčZ˝’®KňÇ ‘Gď(°0ô¶ÄÉ#2MĽGlq đ¸+?˛GrłíĆFűůóëĎ˝kű޵S©p»“Ű„©Ľ~tHŰŁ[]|¶G ¨bc= „ʆ·ß;yé7 9-RâöJ.Éü´=­lü¸:űË&1Ă\ y¸N„–¬ă:ľ+3e×v¶zőůSΠ)ş &ÎlˇĎÇÇzµďľá¨éxč‘R3ŐÔheĹ»ýč Ô"żFŕK˘M‡$Â8űX/ŰX—?­łbü‘Š·•Ź€7«őC†ş§Ď`?K§Ýçűć×^Î_o[wĚ8Ň»Nt7)íĆ—űOĄz{}š%,‘°“ń÷_Ň]=AkH7)/đ"şĘ!ĘçCAţµu°góÉŕ˛DŤďśŹ{ZÖ´şC˙Yw˘hjĺ<˝¸QÍ3î~`†—$źÚ$šc®^ŽB¬›,ůQaŘM҇„÷‹ ÷„©LźŇ!}t9ą2µ\÷şŢÜgF]‰˝_ós!w-÷­@ÄSł"P=vüc äŠ äŔŔݲ˛rž´CÂí…n›qH»}7”&‰}pWdŮűR¸!gŮsµ—¤ĄŁä¶ńZőЉ>¸¶ó»}QęŠG#'ŕŃĄđřűůţX¦—÷őoź°˛jFyOÄ)ů…ČĘٵfOšE» :¸/Šť ^ëçÝ/ŘęBgśb {ś‡z#­űő®ĺh\ć÷ÜUĹÎÚV?ŰňöĐtŹ™†¤µĽ}gdŽý¸í1&Ś×Řu[ꬬŤ…é˘xíÇ^ü n¤ÉUWc‡ĂXşŇ°ŢůŮ ŽÖčőn!AŰťĐűÉ3ł]ĎÂSóâ§Ä2S˘ĘđţĄÍ'uřƦ@g<Ä]ŮDXµw>ĂNeöVNő«CK©¶eţ–˛ß¨Š_]«dÄkG 3‹Ć Ržç¤„?YA~÷ «KŤ¸]"2űş‰ł\QŻ]E°gŰ2)oŠ%mş1FŰÝiĚ#!)R¸*N0so§¤Ż0OŮkżť —Ó|[Pł®7µ±Ťyä¬Çtݵvtýq{µlD©*G"‡a\'ÂW|éŮŇ7‹á>^+DZńpZ\™ty’gťjŐ mÄŚF@ËăČWsy˘v†¬Aű's˛"ô ;Šä”¦#X+UězB-XŃ“™«K{‰ŔÍá Ěç~ů©mÜy°ČŻéÁ¨>‘p¦íQeäĺ¶ZoG€ë<č(´~¨ąř¤ŻW90!aŤą”›Jܿ˵TApę˘čřłĘĂ2˛®ć–ľ:Ś#ÝÄOÍĆȵ”6,´Şüí5*ÁcĽDn]îŽĆä(;Kžô੠5A®©|Eµű–Ř%„ h—«Í=:Ţ ČvĐöEô°ćI(ŚÖŠýúPCĚĎ»˘“řťă”zäS…Ť„÷l$™ŹśŕݤklzíowřČńCČSRă‡!x–獗B—Ş>~E/öé+ٶ:Ě<Ěą‘´˝×/GŞăVň>N?Ţ|łĽĐ™GąąxŃÄ&mNúR'TÂE•"SV>śf†Z*r. óćý iŞę-1@~r$űLÁWćeĹĆns˝ ŰeĄą„†T¨z×íâÎřăÓIV”čÍPĘ— ›«oí)ÜžoČAHĽ2·ŮfQϵŽhśY!]Ő]†'Ó8kÝ–ŔqĘ…¤ď Íý®†4k^Ë‘ę®ÍjŰ·,ŁŇŮYa:47l°{Ř/›ťHG˘8®Óîí+j}×CťM…¶föoFxĂ8yŠ&§žu§¤Ćh#H‚[ŰŤŮŠ±DŁ•µl§[ň5jćía#˛äÎ 5›«,0tŃĄ¨ĆŃŰĄ +ˇ­µ÷Ą,ž­ÎiŤięŰú#ćeČ®Î6{ńÔ óĹög"9VÔÄJ5ľő÷mújoŔ||Ą!° áňŽ<lä$N^€ „t”¬ę9ű!…H5l!=ÇĺX“¸-śA ¶…«Ó…ąôb«?Âç?sNXkxůřŠĎź8:‰MqhŤlÇ01sź‰{âY ě„ž/$ d§űiőBëÖŁaU»Ą¦°&[˝Nśg˛©Śq}4|†~~«úY†Ö ’r™$¤c˘ćQť4şŔÉ˙đ<Ţů±F‡˛ěkŻzEÓˇĽyGŤÝ^‹^ůîÝŇ ő‹ŤÉ}fMci|ZA•Ši<4•˰ź(ˇµ]±ĆOF"sĆőř€© [5‰QébËKö‡ť®Ů÷Č.ޞϝş\Ô˛OÁHcCŤž0+ÇG­°I3ś"÷ą ǶŁGĺA‘/§ç őa•ÁZž}—ް?š>ôö˘B·ÎÉšS—Mˇ‹ŽJŢŃC"$zŞś“›üň”@­žÓ8ŕ4>FS‡íŠőădTV ]DĚs‡'OÜz×؛я¶ˇŃŁ´óÇĽT- ň‘üޤäú »bˇżŠôpëű:U÷š[¨mU™ĘĚ2âd& @JoNA fć(˙‚\¸‚Ú-oŠ0M>­ŮŐwXáY?١ć‡DDˇďúă#ÔUޢЋ-™˘ţpďFKTQÖŠS‰Ó^¨é€Ú~ 6)%µGF­uł8ĎÍĽËO ?4)đůö./ĚpvťE›˛!ľ|\ źwĚ čPe›×YçÇ*wŠ›şâČĚźŤš$řĽ-i!çëysŞĹKď+8ÇS†“E_¶ÔčG™"«–Ejě2湼“ ŻçÎÉ=Űč}±Ă×69¬~;s¬—݉fšÓ^˙CúEđµhą'Ö¸ ʇ3m-;Żb/c_;´xüŐâF3ŃĹXŁRg]µwłOó!dĘźMnE 睪vŃc|jAĆ>ÝýT[ť[K±M0ViŤ%%ŹöĄ©§Ľ°ĺ2eYO¨dŰ=ľ•Z…{Ö€uUŢ4MÄŰIxúHí’"“¦˘ LSwę{چ÷KŃ×î@Őí›^ńŤÉň÷Űˢ&Ĺő©hŐ÷ÚşQŰĐ|T´ll˛˝ âüÖyő ©˘ńëů[ň<čŠęÝPąÜĺtň–?Ýřa[:ŃŠ‡/¬áKšI°°I{EźNßp%Ž‘ŲŰc˙e9© Żiyőjă =ŞWß:ą“Ř÷$Âq›čˇdÇ1(ámĘÔ7_đy¶°±/Öx¤ćę._­cçßkJŁjÂ˙h˙¨c2ŠT‹KwµĘ¨§ŔÇNĂKođA{˛¦=•ŮĄâšőÍC•熴ętí¶?őĎ S\öcŁiÉ|¨ďÓ3¦E »n6`˘żÓ ‚µBóhôŃK,Ěę\âW«KŃ PB㏖Oťąüď0î |9äręŹ!˝&Ö{TżňW#ůr ňŚŁ·Á±÷ÎJ[“;ł,? tâťäÜĂ* éĘąÎäVaęÝ!żÂ‹ |Śź(}+.3(Őł‹|¶»l âŚUÜ&—=#^úđ­<śűÄŇşâcĽî¨O”fY?‘ĽÜxčÜóŃ–eHűd\·öľŠ˛tEóm™AVĺü"¤)S>¬”Ű|Td 4ŁE~Ůr"Ióň ¦.ëŞ`n8’â;ă”’Á^'G98AŞŃą/üó¬•%0ĐîBőĄ|ąÄć†OşŔnÍüů€ Ţᆪ΢™©×j»öÝď?Z<’çsé#v ?gâĐMa~őśő˙‘–ŇΕ"HUu[QŢ× -eĘţń«fň˘ČA Ľ™ëĎ!žš),|´)rç•ĆŚČŚş"ř0äđ{Á=8î”—Ťs9ŔĂăwZÔóĘ _ź\)GÉ*Iîk~é˘HˇrĚAś+/žC…ĆŃŽŻ˙ş+˛lĂĂ Y»iúüťĚ˛€y ¦ ďŤ ę%)ťm9“cˇ _ńJcBUI˝˙;™‡Ďw5Ť×4AŘrę!ŃÍXSî+™Hh/h í«^§ş§›DwfÍţ ČŢľ]ó¦Ă”‰¬r¨Č¤OúZ ś{’iÖ§0÷ˇ…Uµý%kď’€@ĐX‘±q,Dcľô|ő¶”Ży5‚ŞçÎ ô‹‹ę{ćâÂkBÉşlĄ˛ę(ˇ±eţŕ€x—ŁďŽ‘}ŇţdŽčU“$^9sőŠÎË:«éFzşl˘ĐyÝďÉ–~‹É ĺ5ҧ§ř$ç:|­"°Ćłăyq6ņż¦šP1"–Ú¦˘,}»ń·×”đ*ŘAIâµđ±™±{ÔĘÚ§y"˛ŠI „j¤·ÎmŔ ą˙6­nc[]° "ĹÔNęáŰŤgj&yY$„ź~g˛÷·‚d†l±Lu¦/µ“1q].ž0Qgůä“Mźš&Ü řr©ŠL{Ĺa’¶Ú4n× Ă™–ú„j Ť!·a!×ű«aH X Źđٰ96&Š˝ŕaő ŔúH¤RŤĺĎ_­–˘eŤ$ŁŹ0G~O¬±óŮ11lJOéúáÉ"6Żő–Ŕ.•Eł˘®ÉVyô‹řŤP_+JZXŞÍ”öüŰ•ńT+ĹPi9NGÁ2 ŚĚ*—–zMrď¦ŇQłőöâwŐ‡Hűĺ]ć·ä«cTîɱ]Qřř¨ ‚¨}ç!{$úĽÜďö%vXbg©©)B"•éł%çĎ,:WźQĂ­z´ç„9M5•%Ô3& ÄgŰčÉśS}IßńŰÁ2á¤4Šđ&şžŚ­wó‰ÂŻŞÔG^–µ˘§śxc“(Ú­Ä}ÂŽ”đýŻţŮ6ş&A9îöý`qľµClG&hđľÁĂťâż5$, R"©J`{Ň]¸đƬB/Ż1Ö lČB¦ŇďSÂÄŚ’ÔóúĆ«ŐĎ–Ő?pT˘"ĘÓŁ7ZüUđt;ŃZSë6{¶ç`çÜŠ'Çôz`Rëtó¸G†Çä;aß IK’É4Ąpâ\@<=Îćčrt…$höP»ŻÓsnôQŰťtŕ5x=:tÉŹę4t\_Đ\EśÄĺŽč-‘ď2l#ăűe6cŠ›c–-FŮ–w˘ę‹ő\Ă>¦đÜ=ą±ĂÍĂI5ę˙ń?Š3mŹ} lf¶bü}ŁmqqôÎ,k•Xş!Šďç2›R¶…~TĎ9?hĘęžÖöAw6×ń–űĐF‡jĘür¸IśýźďĽ,„ćzĹ@‚ŞĐâx¶ŃżŚŹ^śĎ39Ř ě;17b{\§; Äk4źäĚżgh­´M›ĚJşOĄ ’€V¶öô˝ŻBÝ´::ţŹIÇěŮúSł bîx“ÔźQGjŰŚ‘•'¸ql’íXy¶ÓxÚď´%ŇÍřÂcŁS,&ĎiŽC)(Ň’?ş{¦×÷8ŹéEPĎleşŃ"ßÇ›ňE±¸tN˙üXfÇ őěŁýi"ĎŤx XĹâ™ÁĚ>·@W6$ą’¬ĘĎۀ뾶î˙ń÷¬ŞÓÎŚďpťÉK…!ŐŘxF†°Ű)3éÓ$fKÎ¦±6d„8PXĺ]Áű›}>˝ü1"{Š«©Ě×ĆóG˘=Ŕ© TË0!™ö†¸yůĂ0yŐ ~5Éd7í7ĄZë1u«fičÔz¬Ű«ú×AÔ'{…Kčîáx¬=bÚż|óጣ}Ĺŕ¨a˛-Eí—}„GĆwőíôß"ěĘ_PK1O!\éîGČĚ";x7Oš®śËqŕ­Ę—NT¦Ů–áÉAH€ż§`jšđ”Q¬:َHEᇥ/>sźHŕ?xĆZJ€I-P°br†nÇdĆňF|pĐcˇ?hzŘ˙śBĆĂä'#MW˛*ó­ŇF0Ň?ăf Ó»ŘË*řőA ¦°™·đł>ú%RY·AY™d±\5+Î?ÁÝ tîę4ř69=¶}÷U?,Ž˙ý+D×ËÇŻ.E3ÝZ Á6ć^Ň<¶«â‹ń˘`‘¶Á˘ű8é ś ÇĂň61Uä1+­‡ÓÝ #„K‰€t%ŻşnMS^6ópUÖWl»ĺ©¬š2ŚôĹí„O)-ěH*ChEBŐ:*í»äô¬‡E˘Ě‚=‹ź|Ę+t`ĎĐEşßżżYč˝]َE/._ŃÂUťe0Ě–ŕzXąjQˇ‹§nŘ’5­w‚zZDn˝%Î ůÚ0qşŻ™Zó̢šŁ–K'naĂyâgle@YŽĺ1MîA@aĽ'‹†s˙(oŻąŐ/ÉŃúČ'«Qžă©püšfÇŘ+TÍQ”—3Ś—Ő0_ĺ`™µCĂĐźE$ڞçl?Ž ńňË<_Hśúý d™ď÷Ą2Ůúa¦l/×”tŁŕ$cÝN•rĄüi÷U˛|ă3Îétű)ă¦4GÚ8ŃpÝîîËh{ăˇď6 ëęfşš“0x|NNv‹eôĐ\ůÜ-¨ĺVŮUl!Ť†…Ç_ÂVkE­Č1X1^ó×n9&Í_, ‰¬ÉO–$3FÜg?%Ăŕk“§9ZmĬruéËóK‚÷˙tYď“g¬rŇŐź?řb Ó×Á,ݤ+ÜQ×2“Đ'5ăÂĽüCW–Nq\Ř˝·=$rS˙ćő¸Ô|">¬ţ2üĹŹ§üo¬›Ĺe冞4çÍňq°ÎŽŚÔ5†ó<äv—±9ČWě0@š”_D (Tü"‹÷´­u,ą“e…ˇŹO†5\Ëě×>đĚÉŐ‘Ôť¸ź¦ęlŕXĆ Dň0çaę ĺز7¤*Ľűťś^fLP­DÂuŤá—ŕťQôqi‚ÖUnf HŇ™ůĺOc]ĄU䇄¬3‰-y&[·l®ňe^-VĹMŤ·# )U†x\Š~_u¦â1Đj!““}×}öÉ«&6’ÁŻŤŁšÇ«śJ± afmETaDş^/ćC1—;ń;Ц´Ú%đÍSŁ}‹e¨M˛–xűřľĎCďš-g7UřÝ~–—ĽP+:UG‰Dńálř *y·öچ€}ţ^Bdđˇ26b7náÎyc5±sř4C,XGFŢQę$—ŮĐĐŮÁ°ŹNľÄ}©Ă]@¤.‘ď‰i!vŞ2EFNŞkş®µkíłć\>{¶kĆ›»+2#âdŃrŚbž4˝Źďh{3śşqu­4t)Ó­ňŁN±~™9şńq ®§č Ę7SŕXVŐÍřlhnOfâQbbî3IA:ľĚŤšÄ@v!܇›Ô´ę;ůYŁ*4°Ň˝j—’í¸Ś¦Äöşó0‘ÓÝݦĘ9Č)“?Lu¨¨eQôÄlŘ·i|ĚňsŁr†’«rÎáŰ­ąz:/DĄş¸>Vě(Ň.D”9-żß3¨iĺú9¶bŞÁ¶ =ý4űóÄ—í:˛”őľor”F˘A§·HW4|Š]ĹZ禊uŘ)˘Ü†uYFbÁ¬V®üQ¨®”† *ŰKÓĺ‹^m_dÔÜK r«©řÂ3“$ľ ·A÷gÓk5¶5‘=:¬˘Rî‡',u¤ěęúĹWČű{äÜ•ŢMNĄZVî|VQýą¬xSôIí«'Dë»_?0ktíÓpŚiČnw‹oľ3ßq¶}^*j—Ű˙ůÚ¶™=ONipđvřYvçlŹF ’ý0ó6‡÷ńˇ>ĺ粲qÂýö Ä öŠr8Đ4QŚą·1ÂÂ^Šżj$\çşÝîŤktˇ:˝8+o1޶TGTĄžĺJlrĚîĽ~’!ştŤŕÓ,Čęř Ŕ7•8®ÚŘţî. Ý”V%˙µ˙4­WűŢ÷\4ŽĄa‹ô­őÂy~E˘ µ¬†7 ś{ },zÂ×@F,Y©ýyuŔ}®>č›Ő,ö­ŕ˘wščłŁë;ă#oâü Ës Ł<ŚŮĽ–Ý\-ť7çcÓ #öwîô™Y(ĆŚLD¨ő 2µôS‚ a6 »ů¸®Řń†9zâ’'˙z-B™EAHm ˛LĚÂÖ*,%:wHż™v7má‹J`‹÷¸5•żź>ź.`Í-*śŢ˙Ŕ'űâĂôĺłHćţކ)š-­~D 92}KJŁŢ*fÂý4|»X’Ŕę—{[O4ĽŕŢ.F…»ąŮ)?‚rQŮW•ćčÚ• Ř,_N$â""€P@`n÷ΉéÂâĎç÷č´Ě+b ě#ť6bię#¦śżÂG/ôŞËšđđ(U~fç‘­ IcůppqýŽHŰ0–Ź»ľ/G}p–<ɆM†;čâ y­Sč4ĘÇ6Ëá?Ô¸¦ZZ¶±9&î´<\J§â¬·©’ľ{¸ť¸#üř npb¤˛Í,Ó˙*†•1®âMô˙Č Q‹˝ëeCŽ‘…éOe$JŽďsť«ßu‹·#Ü$ś ł†‘­U¶vČCŐRd´âc?ť yPň%´9ŇZáoÉ|1ÔmUŹ,ŠBĐ«gúVý|Ć\šgx^@ňŃ1QOBôĘďťS“n¬ěÁauW$NŘ—Žä‘~“ý•čk6fKęüCÁŢŚ«Áé\VÄŕgZžú}?_§ ďł4‰OÍNżzułoĘůŮ37—”SŁIŐ±ö0ž±†Z§ă:Ü!¸¶ŤžöśtuOÎ]Z°N|Ä!V…­3Ú1Ýa8äA ~­lOź«3}„S2^B”…#ö˛ú™Mľq¤]łO>ć·Ä{L†‘&VnkTýŹë7©ÇŮâz’„§Çĺn,şDYŹ÷ę'(śF=f0Ú‰˛Mťćé>ńC†BÚ~‰‡'‹>{+38M,žłý~­íyŞž §™‘dŠ_°ü–ÔjáÇP1‘2@ś¬‡˙Dhůaęë(çik·b‘-/K2W<%í?¬Ë÷vşđÖ˝‚Mä°MÔŰäuÚ›;‚÷suźW˙·ŻoÓß[z÷!á¶eş5 ţĽű ×%3!·ç˘’Ő`wą†ÜšuđöMđŤŃĹvI~÷0?Çžqťç˙ŻŤsęÍP”hm[»¶ąk۶mŰÚµm۶íö«mŰÖ=ÉÍy;?a2/k’Éâ+ĺu`"‚ÉA­¸ÎwäDĎ÷ąÂ·¸›™´‰(“—żJZŔ@ĺÚ+`Ä1:C}ŕwé®É:zE`=[ť*8fH‹„A¨ădf§ĘźSĎ jť?”2JYy¦ą•Ħ‡UKn7P=>Ô'[Ô Ń˘oXŤ&`Ż@ď9DżZ×DăÍÇQL!4«=îˇ+ÎÖ˛i“ ”hĺ„釿 –Í˙ŕ`âzn'ëgCf·(Řq5<]–~Ś_—Ť¦;Đ_'O˘hĚŁ[RvLV^Úd-·¬łÁW`ď™h° ˘PAŢm B8ź#v§†öđ±Śűň=o2á«9Ó•L·‹ż˛«Ô‡ĽÁů osVď2ýĆ“Yű\ăo¦9B‡0]¦?OEź˝Iĺ¤bľ—„đĄĆ^~t¸µ Ő ňˇYÍ€Ůö›Đ4f„!^ŠfJé @’‡ŔĽHµß™0N–;Ů> ·üíOŐŮiřyüVÖýĐüŠncî9¬L­\|BŮÓŤĐÜŢŻď˝e5ä˛6»‹Rő9WŢ Ą 0?sďú=Č‚VË4śyÉh1oĄK«Ş“‘öÖ‰fŹÝé)“ź}Â]VĎO¨3 Ś´;&ţí>JË™.oRľ}ő´eđ–¨e‹Çne¤xW./†*Šy—~#ä@9Ń31‡qwQ‹Č‡‹îϸ/ćG›Ŕř 9·ĺeQ9|ŇmN[_Á‚«Đ®?sŻÍ~m˛¤ÇHř˝~đMRx?źú[|‡*LÇiçˇífä:źÓ[•ĎĄj]G4ü’Äě!–⊊˘™ş Ć‚s”ĺ4 ýÇ Ó›*ĺÂ`Eüëł,÷g—ý%˘`Ξ ¸˙ŕd'ĆA˝P ™¶ÜBű8­ĐaÖůĄµ\&8›M'Qš|GuŠUĺşTÖ~W8žaˇĆiJ–‘XćµqU~|m&d ˛îĘŻě¨Rç-ń­rÔ»IdŞřI+ z'©ąÉuúÇB%ća…t"MW/]+ÖýĹéÄĂÜ$[č2zS»¬( ®ătzfÝ­Pc†Ú4/ĎPs«µËDV§ŃMčz-śęꙇˌľq d@ĹÍąâçJ9ĺ;c––'ËŽŃהڧöüÍß!6Ú™ŽBä ĚPýŤĽo9‚˘ZΉ^U„šY†±7…˛¸0Ý®÷“§:P+2+Ě:®:…›Îýw[Őhźő:Şbçś:wTŁaŘ»vk6 ëuľŕ9Öé,s/R1PJÚ6řbu#p†č‹1$XIOW¨€LE`Ó=T€µ3üwxĆňeűz Ó@䏽Ϋ7‚oPµĎ÷šŕŹçIŞ˘q!ĐLUú"É4Ö;ÓâjËďy‹JŽÚСÓ=y!u1!S† ›˛°“r>í”s ŕĘÁ ˇoú)Ű×tb •0?ž·łS%¶Őo>f擪`ÝJ3ÍćwťÚâ ‰_u梜RźEAżT> 1O‡żôYń/Dý?XÜ,͡Th–iŕ{ő` ‰=΀bÁîmůŠCo·"Ź%YbÂą{BĚŹA`’AÎw?”ĆĘ;W¸ÂŃý+{ )ŁNĄy˙Q;ęInűŽ‚77ŁĄ¦ďÔlŻĄŤę†«ô«LKŚ50y¶z¦B‰XoT0ŁÉQě—=Ů…;S‡a—úf4qna{…Tku<Ődoń"ő{ő’L"®ŐňĽdô6D‰‰YżÂ˛T"ĄÓ=‘®!QŘĐżaąj, ÁŔXĘžŻ÷ŹĽHý'ş&4Ď˝uŢRöŤű|Ó㏟üĹ’'¨%ЇÓÍđćIŮŇ(Żí1 N`vKś}&$ŁáŹ4Jjďl!ĹĽżD1ü†S ŠĄ`ωN`vů]AŔ…·a Źč 0üÔi|g%2tOćZj ×Uöi^Čô¸†¶CćQ$s%ą«ŐżÝ ‡ťc†AÝAľGë]Dw&Y•ň»Ě9$]l«…/–;ŰzZ"^2>JąGXK·%¸G˛’ ˝a;ö‚Vy_z·? Ń»+rĚÚă\ű–ĽĚÍĐf¦“~•ć;ĹOw% Ôôľ? ¤śâÝöą7·aţł<_ÉÂŰßąŇv;={/ý †Ôď®PÖülĐ{ í˙‡ .´uËnĹv đ_Č_ś­őA‚ŠSe쬛˙ ŇDŁ<đhŘ ¨9h‚‰kí°9ażŇJ¬d` xÔiűůO‰/+¦ÍQ“ŤT•9ďlźŹ¸ óă±nrtŤ·ł{GH§Îjq‹^[©ŞZPţĄł†Ą4[@A¶ÉJc® 7őÜ5ŤmĚůáN^DbfQ 'Đ|ćŹ$5ů´Żá“jpXý ĐřXŢSĆZ˝Ŕ,-ťąÉÇÄ™á”Z;`ŔĽßwN"{ŐmňŃúW‘˘Č¬\)ö˙™Nl/†ŃďcżHˆf`r}Ö›;Ú¦WgoŐ` ÁµËlduUŹ˝fXFď+([?4_ěř& ™5Ł.׼„ô‘ŕéűÚ¶ű%i†c+™%-r-ëĘ]é(żP×OKt0ő¬`c¤Ĺ;ôć36¨í ˇáű‚1‡~‘ĂâMă…[Mń"żJ˝Ý†Ťç<—h(a6‘ťßËť‰JűrśłUźíŞÉŢeŽĎ/䇄©ý2jRĎă‰Ça,ž™“ĺľŕ1ĚN´ ňí1Ěg3;˛¶¦ #ž,üEă›nŠvďÄ'& »Ü‡Ţ7â>Ř˝ëlţi#3şU&J}ˇÜáµŕ9ë~rsH€$A®‘ć]T9˝ěŹ˙g·Îú—ĹK6[ˤBDĎRőě1¸Ś«K™Zžn‘é¦@–ö¬ŕŁ9ݰ'ň,÷K^„·×‚Áćů•»˙6őřRB=]Ý GŤˇ§ég8•ŇŁU4U°ąAŃcfpS97ľŞąTBý¤IţŻBrxŰ|5ăŃ^€>žXÉҢŢbź~íöytFçş÷@<š«ÍŰů¬l´XŘߡ‹ţó´l˙ľĄ¨Ft…kčü«q‘ś‚Ŕ<ęł~ón]ę Í*µ€%†v@ŁŽ¬Ö?ŕůHľçÔ±y&+˙·ąPwy/mëőńĚŕ,Ř’ô~µA§ńś5«ťSkc<Ń” vuŚěH¤qŰ^Á™už+µIöP=É# T[6·y =ťŁ8Î%ţkÄÓâB…Đî,|š…Ź‹g¸¬ĹťF©Č ¤ ±@Ć÷ő€5?µwá.ńÖ/ŇŃc,ËŁ˛zŹ{âţCrM1ÉX6Â1˘ŽNéÝŚÝ“&ýš˛ćŘqĽ„çąPĎŢ\/ŕůGŐ·Gě[ź&¸TŹX\î–á~,18SĂš^ÁŢ®’Ä{&ą?ĘľíXř0NS8›"ż1ËžK,ů±ŢďtţÎě–~ces¨¤řÔUů˝˙nť:zÎS±ÂBĎQĽN…Ě"gÚÎ˛Ó č*k`Ű:z\é  ż{’:Y˝ OŐCşmč^ą;Im b»ÔlX”SÔRżzƙ߻ÝwçŃOÜWNó7Ć)`»˝¬ş9l×Ô.ŚmżŔ&­ČN/§ĆM$IÖń„29ö[^w˝ĹZ Ń–¤ěř> Äϴ܉yqTÄ×±µ#j€ľWb<#ŢU© B3µŞvTµŕU=_ľF] ‰­´vPhoZ§ÚŻ·.Őýy*÷™™‰}‡,_ŤűČY°ęÁş{k­ČčblđŢ˙kˇĽkß§Üé~ń™ÖŃGŤěí„Đ…·Ü “‡–±g7… Â#Na\¬>ĺ×=ŹśSDRśßŤÎ­r+!] ŕ'Ę4]«Ó$ˇtňkŹ Ő˙‚ µţáMt­?Ř©DŚŃßÇź+ĐB{ó& jă§Ew†nEĺ|ŻÁŤ®×n;Üľ¦tmÚşľD.ŹÎ"QfŤ3Ď#‘'ÜŐ‹Éz:iÍ›ÂůWĚ)a´km ďqÄIÎk!nOh4U›Á/¦%)lný)ëđ(ˇÉˇ"I¨‰Â& ˛ÍCłů@šĹxéWžwĄ¦]'!Ě ZÄl]HŚ#w=ŮËsŹü겒ľťkĚ7žÎ4ÉŁr]p^ŔˇĽ˛=ŃÚ˙C­ŁHăň5íâ·»÷ý¤.榵Z_–fÇţ W8R¬ţGĺşlő0 kT§Ŕ7St?X$«…–5"ţN\ó˛ČŻ8ÎgěcîőÔř Ňć/§­Ś+ÄHVăęug$R™q6hk‰ŰTżŔI«Ě}Cöş‡‘Ţq,g'ĹDënAčuşfŞć_ń#4P2dÍ@󟇡5gäŐf‹†Đ’ڬŤ˙ö2ŐúéŘĺr˘bj;ů`{{aĹknTLöŰXNÄ‘A6É{ťQ Ö3!júöµťÎťygŢĂrŤzą©MÝ~Ô9{a Eýřńt’}!­˙N:Oť°˘ ăÁ¨1«Í˝jDúੵă őŠ–zro=Š’ů:ŐlÔ)ňµ\WT®ć~§zg€žŚëj‡˝`&SO.ß ÜS ĄlňB;Čő©TŻęóľqęfÓ‹ň$fO«ťÖn ¤ ß@11éÍ%Ť VP‰zFdЇ}[Ě“/†2‹[AeŤsiÍÖ=áEř‡a˝µűLOz+8Řw łY{gđ)cF2ŻaŐ0Ýל`_qkËr^˝żëpńýq0Ž"öJ&ÓüXL¤uł±×lţ8s7łO Ôʰ¬Ě–N´űâSŘŠęŘIP„˝ö}‡JP–T˦Ŕ}ěŇĎsę—]X7xŻ2׿łUćQ~Áő©OsW‰5Y?ĆiŢ)Ząs1„¸ÜÁ0s˘°ę’{Ć,îKd Ő›™ŐŠ~c…ąĎď):î0Xc"Č$íljÍöĎ­Řâ"Váv’•§úŹřSCź?yŃŕÜě+űl/„µ&×xzđ§tXűîG(ĆĂř]ęíÍ#€97/{´ÁŃ‘8fVUřP)¬íÚŇÁî"š~o—„Ő¦Ďë_îpöYJzgj?…AˇepĘ?ĘŠÇŁ¬ť;Úx‡ţ3®ą`˛&(|Ą4ÝŘHŢE&:¬­z qx ÓM/J…׺)˘6é€őµź<§„KJôđÚW˙˘ůQ9.ëŞá-źBűşe’›-«?\#+Óxĺ m%z“ńóŕ‹7_FîhŔ޵B°ç‡TżŐHáTA NŃĆŕ®rw=ÓQîľ­'W”ˇDôżÇł.U…ŃŃę!’żn¸ #äKűň) )Čk4Ž-Ĺ-A\AjYąÎnP#ŢĹ8úđ« [ꤿĆ?Tśľ‘›7ꔌŕëla˛4™ß˛üTÍ 'ׇPŰ6±/Sp@Ye‡ă˙ţÁ¤tĺH yѾ̔Ňh®%•¤ä&ЏťóĽnź«ŇŮeIşd]ĆŐĚuu ¶Glů4Á\|ďN'i˛"ŘÚI·‘ˇÚkľÉFѱIŚ\$_ęb©â÷dĹIĺsězjč xÄáŻűűĺ´‡ŇŔKBSŇI^|U¸,莚ď Ç.čŐřGU9ĘfAżxĹ—,D÷3Ű™č9ĐŹ·Ć4KLüp®«ţ–'‰µYĘSÖyeüiě+0—‡BŠ[čmđłK9Âĺi=']-7Ç||čŠ=O˝a'swŽSĺDŐ zGŽ“ţ!śQĆ]ĚŽPś6ßń:„=3vÔů2sć‘GQIčr©ľ©/"ŕ1bôNţňúIC˙Ě”Ó<ÍŞUř»/`Nk"ęšc^ÎŢC•>ěYĆś \› ádAî–gn6Ú+EKé繬Ąî!’ómč<¸Yh)ś&( iłvú>Sć .ę4ÇĹżŐ˙CNh±'ÜůA;59 ĺzhˇ„źpWśVJęÁd^±Á^š’Ym¶ZűOŕµAń©÷'lĐY·>řśÓäNZu]ßTŮcZÚíÍË+úĚRç¦Îá°Îdi°I JZݡ92ňŚaOl˝‘é[Űť Ş~É*no†ľ=5°¤ »31{r¸IňëŢSM TúŃKčŠjvÓ6 ú€Â7~˝©ZśĄdŐ=ń±Főqě׿T“Ľ§H7”µĂccl+Ď—Ôć«%ą6YşÔ1˘]iěµđĄ»@ă ő§¨ÍŔаęÜî4Ň_Uęmí+쾪 Qa©ăKLő.ĎýžŔÖççşň6=T’^4W§ŻUŔCMŔfb„Dů˘i,«ňvU^‡Q—YüťADW/î˛I(ăqŁSK49şđĚŁ·¸;cvą1ő>ÁFîŁÚ-̦”ü"d{˝ÂI yÍ jßhó2‡a⍂F†ő›| eđ•ä|{ÍÄ×wąŢfAZbÍ=†űäľ{$1;N>×G;ĚĄ’ 'âIÚfĹě÷VVţc€áÁö´Ž¬ŇČŻW{űc­ŢűÎőae~ăĆÇ-rxŔ’$]íŽ5Ćěí•倊™µ%)”k7âţ‹m3{Q®ŰB«Š,ďCS^oz¨tĘKźÁ`Rĺ^J˙±éˇ)9Đ×ţŤtp—|,ĘeĂJ©x‡Íę‚ÖH«vc}u¶“3‹÷)y5ö6w´¶ţ×űwňĹČ!Ł?f'Ă>‡;’ž˘ťB@¶ĘÍ•ţ˛E› ­*Ýöő)äů,Zŕ›ykýćŃz™Ýáóâhą{»7­}ŕOĘ.Ťđŕ@Gž¨ w)FsXőGŻ+†#rË!ôeMŰěy÷$‘͆oVkăR)&ĽkŠĺ<łŐ¦vf ŰÚďW÷[âEç"’• #şŹnĆMßm˙ púǬ{dđçTĘŘ=W!ň'âsUĽ.+ ĺ_`Ť?_ p´ľÇű­;Pň˘eľs y‰~ÚÝĄaŞĐé‹I!ůÓisű“VßÍĆX3Şaľ¸Ż˙Ŕ¬çŰÖ7-?;řő2ýř›ÂÖ2ÍÓĂŞÇ„úS4 ÇŞÚ¨Ě>É;N˙ć[gď đ–žrĚş$3EĘ/Ű¨Ż§ŘZ“,ÇĂ+ÓuYy€\Ő$vRd.ęßÍT˘ŽŘsë ~AohżuşÜŹ•?¸eÎâÎ`ČáŹ~SŽŘňŠ\8  .O4QZA*;‡?9µ‘cT+‚»Äv×5Ú§ ýuđckS˝Í9<1ÜvÇIN;Jµ!) üV‚'dŁćtFܢašxžăŹX;† ü:fiýř´Ą ň‚JéĚ·ëôwÖŰ–ěO:ˇ9 Ôě f ë1KżĄŘ§(cQd ¶KóPÖ 0+GóţíŮŮ@ŁŰ*ŕ$O-%ŕg|Ź ‹qyIŮŚ—%5şGś’í§ßżKQš¤Y*ŞŠy|2Ó ęS7@=€ŻZ„â·FĘörsZlkŢKűµ%SĚĎ_‘,h"T0úúaLĆ”apʱhäSĚľWHďТÜŢ`O«2A^©>>.<=ws1UÖśÝ=é9Ś„­&LóX÷|ŮŹ‡\5rĎzšáMLMF8nX®¬¨OË`8hîj‘I–š˛‹Ž×V6LyxŞŽ¶uŐ+wᑤާŮÉó–-DZزŢţň;ŢΛ›‡ďÍ»§®r§¸ešŞ‚Â}NĚ!ń B U'Źlů ß&RKąŠV0šĹëע”™K,y‰KAń-ŕ‹ś›(Ů›äżGZĽ3ŚbĹu tfŔ[FE–ů?űąňéPÎŮ!…E«“Ś­×·ŰŹąÓQÉbApĐÉŘçŇř•í,G‡H˙@dˇ´%ňšÎb{ł{˙e‚„E4-Y6űVž”ĺwŚ„D¶đŤŰÂĆ/*Ĺ­,°ŠÍYCŤ¨§°řFŠZ=':#„—2›ŕ‰‹té´P’ŹPIv¦DĘÉ©ßß­đŞ\“ĚŮĎ/^ĘBŇ72µőţôMO ú™ČaLâL‡p-«źŽH\öö%{«®a4¸úä?ZkҠ늺fÉ-aDQĄ&MŤŰľ…@=Ą0Üś“Źb>są,޶h/‡~ęoޤ“ooÇ•\qČey|hů[Ě›ŃKĽH"űD˙Ű'`ÔŚ)ŐŁá'Ô˘]0sG;~†^Pd·®f··đ°Ä)4É\ý)-IĐ—neŻ4żůÂÄj+6(ÜIĐ Ü™ř ×QŽN­)Z|4vŰ#1ýÄĺ 68ô' O^D#c{“ő,ń÷ęžž¬ä|ŢďC>×ú33ĽÁař‹ŞÍAˇ >ućn ´.YŁAż˛Ę0pŢÚ„łcŮ›ÜŔ$2ŘĽ›çҵ¦y•üľzĚ,˛RÜÂDx¶O$.ńüáK: •˙Š”*ŘőŤŐ#°'AŰű{TöĹ´áŐCay»„#FĄúôP!ŢŻh×›u­¨ZÚJ÷c6?Ď@bLÍĆńâ4´,Ă €ˇc2® Ęŕgź• §(^ć¦â•;ß "m<Ń"*Î'îÚéóK 3ß ˝ÇqüÂMkXnj홡]ýé)u¸k™ę5žÖ÷˛lOa}Ő‡ëąűk•ś‰uVÝŠdsÎh¶]ţXf´É‘GLÄ)úHV„%—€@đ’Űľ»,Gw^>űDză…}U7ÖÁ˛ŃCmˇăýLbeN9•mŠ 49ę˘É—8]ú‚u˛=nź2—ýĹ&ń5T6ëy{K;+1&oÁŃϱ‰ §ędصµî„Ŕ%M> śŹW)%íoŰđ¨7ÄRě=u¨˘ßO6rçE»_¸Ş°†-gYF] €‡SŚWh—ęşlh˛ âcuĽ5gpF«a°źŕ.1Dű”]±¤ q\†Á tţubńT$çy&ĆÇjĄî úLá$ÂŁ—M^+ŐHXVl‡v'ëŞ&ňeäI_jŹá†‹Ő9ć»éţv¨vkĺ™/ßŐ¤ćYŔ{•L2Âř%_”QŤRhüĚ+‹XĎ R̵ór{,çąkJH+Sf¤í<";¨6Iŕ;Ę3úł_‡ÎQ[âd)8an˛3Ź„Ů¦´%!ę¶í@EĆdjŔ«UßUIÍ,VJ=5Hu­7Ârâ§Y%u#/mÇßB‰ŕ|ĺ}ăž1|ż[ssʢη÷˝Ćúŕěň0zM˛ű&ĆŤµ%#Ww&]ĘŰřÔĹ}4NT!‘e-€@Oś«Îçw›ŔšŕĽ1‹\áK6'ٵ‡Îű ľ®:b÷ĹďśY×Ů_ŚbßđënŤ]m&Tl¬5o ‘Ťéĺ?«›Ó‰h^…·:ÓŔźŚÎ‡ů™žŇ\LťČˆĂVLŹgú¤i‡ <Úő÷cĎŐ…pď<1麎¸Ł~GA²qĄîżŇŢŘ(*Đ3ľfuX¬Ł c„ô­S›µ=úą¶…žţŐ(ćĽ YYľŰ×ŇźTt·ćĐAÁ’é-1?5“ÉĂiźÁä łľ#MCÓ™\?ýuĹŘĘě9&ć[4Ë0%fÓ§[ěö¶Q.űzŔĆ0ÄJ>(L8Űo÷»Ő?×Í ÖQ«»Ťą$Z•Kţę)iđ\ĄfnŹÖ÷ÉŢzűL˝Ď1ĆC]ô˘2žŐů¶FŁW}°¸ĂsŢů+ł.}‚fݦˇňĐw5…ëq©“CŤ*kŰKśĹ ůc˘Ĺß~PÄçđB§drYó9ŠŮ‰xfhË»Ą AxS1Ş.„9©ş´ąÁčőřWVa…*Â’U%’ň`yáő¦Ć>¶¨ňdřëw¸ůĎŹâEŇÍ“&öÝĺWËšąĄŁaŮ µ«í¬š„Š/„t‚łrA…1±" Éů­wˇ§ŁtÓÜabj5÷íióe&Éş‡DńćŰ+ˇ{©Y®&ŹC…ôÁ©|†„yź¦sď`ťänk|ĐëCˇřnŹ/¤o®Šh t˙:hŰ­CĐ'ívÓbbČů%cĆ-±C dc"ĽÍ’Ľ~!:g&›Ô‡x[;ůŔ·e~Á[´ďŃßý߯MVňíÉK¦†’Ncnđ¨Ő‹Q˘Şr.! U„?ďČĂßĚƱűĐóÓ Ćď ţ‘I Í PA7÷đP"§— *&F„]Âv>mMWE¶_NÇrúyeĹď6)ă7\ Á8⎅ş’M/$ń+®…§ÜŰ7âdEöůW-4·Ó…ćŰ~ĄčFĂ%üŞş™“”]€ű~:3€Ő 3Uąă¸)Ď“rěm[ˇJĚŻŘö5Ťv¸ Ľ·Âîů8ćřÖÚĘŢÝůEţE(ż$saŔˇݶ ŤÇ‡"! NÎ/'`ms¨ęv±[źéąÓP˝”Ł. -ťÉ'bÝúŃhÖrtaő¤|čĹďM»to Á^•ˇ+\¸ąl¦™…aşi´ŮÁ.«ŹálxĐ•Š­Ůé^ÇcaUťŇÔ©xĎîÝ2¤l [¨Üř¬ĘZUjU¬ÖżäCˇ BEŔˇ5ÝPv;»‚6ëů±$“mjĂiţDĆk’&\KrzćżG4V•ÓIŘ eWˇW2¶!Á1ZtçXšŁË÷$!Đ‚#~cf&çpnh 'Ď„â©H±31,)˘EЬ!JY1šĽ»M”sŃNq,ňÇCŮ=^üäďľ`őd±Ťłű>\* ‘LöĹi~ľm1Nż\®ż©zş˘:X?ĆHŕŹ‚űö ÖCéĐۡ•L¤´8s˙&©&Šcľ—u­ G$Gn–xUšcš(‰ť¤0ůlg!ŽCÖ9Ş–0f8 Ď!B©î°(@6ŮĆp˘`v͆SHŞIe$2 AΔ ŮF|ß h?ŽÂ凧^Śő·Şn ŃaąË½tŘpuźżë–ÖhBO䑢:ŃY4:0 äôÔ§5X‚ŮĹY×»“‡’ÝD6¬ÍEByOá¸yV„Jň>Ćükz~ÇYy#mᵂn1ä˙µŃPCşĄ!ßú‡ÁúžĺC´'«¬Ďĺ‡Ć>§5é×3DÚKM\čŕ~¬źÉ0Ă« ŘËš?˙€ .ĆÉoóz»şé”r^ůÎŽÍOôLg6µşđÜô”`ařܧŁá˝•‡TB>\JëáY†\Ŕ“xX|Ş&SsëMĺąó?,Kż§źź%V)ęuČ®UâÄ9éd7S°ßÎŘöŰşÍč@\Źă~(Ô/8 K ä0 ‘<Ěŕ¦+ĂůpvĚäv ,\G»3(—ŮYo:M˙ý/Â3!ĆwR> ·šxô×Ô› AlX«ÖŕÜáE0­¤çϰe}ir»!i(:!`ażŁ‘ ÁŤŤĆ> W6¬řréĄHţóŠÇâĹG+%ć#M˛n€GI©˘ŃÄ`?RUD…±÷“DˇĽ˙‡îiýö_ö㌼ęě*šRÔŘ®$Fś'>¬ ž ‚sńÁčv5G|Ş*N˛ďŕ ŁaĘäÝ5+·źąHÉay!Žöú˝Q5ą÷ňEsfŔЇ—%Úů¤Ś%Ś…G YžmĎS\ý|áz¬ş*Ţg~3›¨—Ľg1ĹŁçŽóňď»ö'%q­lŰ&„™¬ Ó  V!m~ŃčŽě bÂËŃŘo˙EŻPZçZѽ»{” %M[Ď—Ş´T\¬ ôs?}s(ÍZ¤î>4¸!N­u° l57ń;µéŕ çC^ í%Ó>  ‘K=YÉ\™iK“0‰W2’Ś*ČTÓ‰ZÝÚ}Ü…9®­źDÜÄ˙6­8Śü[2z¨kőGí' Ż®9ť÷5=YZĽŰÇ%QNЇšý´ĄUĽÇç_ˇ˘C1=N ąR<ŇŤę ëHË•SCđ C<ëµß6dn_Fýü ëěéłę9CBBâą”ňśŰ`'WóŞÍ® é“©yŢĘ×Ă÷‘ínĆvěśmh˛üRĹÄÇ21/.puü˛–GÄ/#dv™A5§†»«a© zgčs ¤\ń©ń(RR2'Hł8URĄůźˇ`qVĆ]4­É€ ,J¦µřÍ ŃŽ¤—ßüíФ¬;ü¨v§ěFĺK‹;;aE„á¶/vşÔîo;euYÝÝěâG}aĂÁGq«k&N¬fڍ[´20ö0Ů(˘ĘŞů6ÔŔg­ŃF? Bż˝Â©Xş ë4¸7F’Ç|ťŢ/řBéŢç•ĎG·ˇ&}ď*Ź ˇ­Ü%!Ż ťn¦sjöęµü^a§tőAPr 9”ż­mŃ2ox>dˇŤČ7(6¦›#ś÷ďĂ’­Ž‘ OUO„™âH‡YH ĄXmzĚýS1 tÇÉ‚ű´‰î&ĄuĂ(k>^e±\‘tx üľŃtŁËž@ÝÂý"Ęy"%l4Óĺ^¬źď/ď+=§ľËa0fËşfTa.ö;صˇt3éŚÉ/SÍ©÷đśv#Ť%´TVlkŐűáĂ+íŃ•Kę®DJř¸ZÎ*±ś‚-`ś" ÄżAŔ·™Éé(a@X o%ň9‰`eő0/–@2WvĚĐâ2š4e{–ă?ö-í`÷/©NËáÉWB…š\#y˝Zv/–‰Ş4•—ă…”-Aţż0íúR}ŕ[Ű6H:ă·ĎEü˙‰ůťPłMÓ«ćwŢ7đŮ2ĂŠŤŽ·‹˝X†.8ÇŽű–ŮőŻAĂ †vC?űŻAÚÉĘ5źyŕ°b˘Fo­ÂŔťň™±BuŐ5Ă*¨,˙@T·ú,ňÍZÝŐđ‰>źśiÍČ[–l7#EÓ¤Ć4?˙¸M†ő:© ˘ĂM˛9Ł=Uý¬’<Š&ýłĺ-ÇČť'%€f‘ ŞĂß”ÂíäĂ"2;I*'Ś qPý3!¸r?}Dg‡=VńŞâ…má[˝ ô47©ż¸ź Ă#§žvą·:»^6ŻbY=iMë«2BJS˛÷+{Ó/€jľV.“èúˇ¬wşo” ?ÖěZDóe™Y% Ôć…­–R˛x“ě »ĐĽĆ,°ú#QáYÎ~Áh$;˙t=_.۵)Ůt&ĺl%VJˇí±nůWđśÓí±čtb3#Ę+ş2ž3‚Ť{#}™ŽÖc/Ľڬé=×'uĺşqÝ EôşáąľČcý}HM(ŮÚ+ô@4 ?6Tsg"Ó(v€żôâVŕxńk˙\~đ]ÚýUĺř»VŻÔÖ4­&2őTóńO"](z87‚FîaľľĐôű˛ißŰ ŽÎMxÄFb ‚WßÝÇQh“±ťJ6“4ą±ď6~iX3âÁIźGZďĐ–QҰtB‹ŇŕÓyI{ĺâřmcőxCťVEŘRŽś$qqŁg¸ˇJ’X@÷/.°6ÍpŇ.ćŕ\źŮÓ»háj/g^>ăçÍ%jf%Ď\JĽ“W.•Áh·wÚçş÷ç¦îr\7ű?Ż%şcÜłĄE‘/ąE“é5źLIĎĄkÂsŃgNĐŠn䄞° 6ěC´Nd¨’W“W‘dMćr˘ĘŽĽhFUo—N· ž‘ ÷Ćĺ6D˘ŽgßNF~Eüśl;Ăîľř}ö–r˝ŹE“ĺűDĽ/wÝ÷,hóźf“ Ł?śżéš‡¸S¦w6K{šâyĺ?ę~şW‰í`‰’b ­ŞęĂ‹"-cĘkY“ů‚›{ˇ}:7™’äˇuJÓŇJ¸Ö^Ž"´DżˇĄ’ ‘†ęz‹ÝR–çď"yk8–@Á#YýÍ/ŘţKőŢ'ćĚ7ؤ†ĚäTDŃh‰1Îč fSőDf]ą&ý–ş«XţaŇŐ`¸üŕ8¤:Ý9hĚ­mâ3UĐęŔ? ‘…™vŐăŘÇ ¦Š×nGR"‰":łB ¶söi‚ ă¬J«‰0\o˸půŔ‚ŐÇŤ\ĆŕđĚ,UG÷žŁK®ŚbMSw]Ő—[ŮQŞŃ­p§¸mbVGS1R5úíHďXńĺngď^>?/SsHŞc_™‰Cž=\•8íň,ĺ[ü'»Žź]2sY ”ŹF”|đeŰnQŚ›1ü‹& e"d×Zt?™ o ÚCü[×xé‹Î*úŰÍT.źµă2˛~ű¸_Ľţ¬°IĐm6_JU´yIVXs1F¨~H 5Hqő‰­,SĽ=xËx”/ľJŕ«fQ´pâ[¬NĽ‹ 7ĺá2ěWŻ`ŐÎ:˙şŕ÷đV^ŞÍĽIR#޵ŔFW¨Çk’rŞ,¦Ç6Ę-.¨c„,ŽÎĐšÉH;Ů U<Ď\„ ĺB‹ßsŢ[dé\îrö«sß3Ňüý–vôÂűţ|A4:ˇldBŻٰé÷cC €¬˛‰`pć­z€«Îꉊí7ě5+ä96¶“nJŻď}>şúďśř®b@ÓU×{rĚo‹ćŞÁçä«3ĚüÝ9ÁJĘ»<Ţ™&Ô=s ´ëIů–˘w9©Ľqîu#TŽ€Ń@°AfŔ[.qŕŠţEŃ*’$ř|#â‰$ âÚČW¶Žę6ś?Nó•®F-í~Éá÷ UI÷Ě&ćđ;®záž3Ç:š˛s—űÇ?Ç·¤Ĺ H tĺd›’ő€#>rYµUźŔƆýť_‹ëé5ËÁn[żÇ±ż¸é–í;uE¦Yq×üüc-d Ă×ćvĎ őΕ łŰÂJ@?CáŮS-Úe3†z|ŚÎ˝&ŐŰUřˇ¦­ĂĆËX÷EÔ{ÖĐ|Ů ¨Ťh,Zs©zR1Ë@by¨:ůĆÄ%ُĄęů¶Ěϱ &“ř?‰q¬ endstream endobj 259 0 obj << /Length1 2537 /Length2 18571 /Length3 0 /Length 20083 /Filter /FlateDecode >> stream xÚ´¸eX›ŰÖ5Św·6¸w/îî®ÁIpw/ZÜݡhq)P(î.Ĺݵ-RŕM÷~ÎéŢçűý]\!™>ćXs­u'Ôä*ęL˘`3 äĘÄĆĚĘPPTŔl¬L˛®¦ö6ćvfVVNdjjqg ©« $aę äđ¸Z”Í]!‘ÎvVV>dj€4t†-f^E «©†—# @gú— vqe23u +"vôr¶±˛výť‰éw¦ßŃbĚ9Ss;°‡‹ť ŔdcVd(= J0Z›Ú[Ŕ–  @S]RM ­¦¬©˘NĎ I¬îćčvţ?,âęšŇo˘J’ Ö[€´¦şĆď˙@żŐ[€’Äţ»Äńw¸˘¤†¨†®Š$Ëďlw ł‹Íď˛˙Ť‚ đ$ÔŇěđWťµ««#? ‹‡‡ł•›‹+3ŘŮŠŮŃţ/|Ö6.°łňî ´ţEŚČB§«5đďż× `cąI˙6:@¨„Aô®˙!ÂőwNűżÝ.@ŕżĘX›şü« ˘˘p0µąA¦ sŁ«©«› Ŕä/ä´ ý  îćěü»†âLÎ˙-óčb`Hgö>~¦˙»b¦ 7ďpóď¶ÍÁ W—ż3–6öŔßč]~Ż™ č/ť˘¨’¬”¤ş“dđ@LŠ`; fWO׿Ľç•P€Ś"/€ťťŔ RI…8ŘÁ‚Úů7}6ž\ÁÎ^,˙;Öv °Čç˙ٶ´YXţćÝÂÍ‘Edă䔕ř?g ůŹÎ č `ť@Osk–ßĹţš•ßj¶ßj ~>Ž`G€Ą©˝ ĐĎĆyCöq1u\ťÝ€~>˙4ü[BfăXŘ»BƲU˙Ę. ˛řţVCüÇô@÷×6Ą‡ěQ 0ČŢ `´DfQ»BĆî˙ź]ö?µ¤Üěí•L€t˙Ăč˙ş™:ŘŘ{ýËń<´żˇŇ)ťLí˙Çfă"eă ´P±q5·ţ‹ÄżŐWYŮLlśĚ¬Üě[4ď({ČčBޛߧÄÎÍó?6ČTšŰ€..nľżL@˙˛żAXtµĹĄ•Ĺ˙wnţň’™-l@Vv.n€©łł©2+dŘą¸>l©¶zţ5-fŘptsőX‚ť‘Ż(7€Eô·ęo‰Ŕ"ţGâ°HţWâa°Hý‘¸, ˙•xŮ,j$‹ú‰Ŕ˘ńG‚ÔÓüŻÄ©gúGâ°ý‘Ř ’3d,€®ö@K×?zŽ˙ę˙°˙ pÍ˙+qA’™í!ě˙GĂÉů[ăŕđ§ +¤'‹’Ŕ? -˙Uű·ÝÉÍÔţ!Î-˙„@°YÚ¸˙#Ço3ŘÍů«?!v«ß—đź. Ö`Cłör´‚ţáŃŮüC„ôúOL"ţl&˙ÄrA(Ađż H.›Ůď=mőŹlfÁP@r‚˙ĹĆAîřÇ ©áh 9ą˙µTśl˙§ý÷BqBu:Ű€˙PĎ aĹŃr'ü„'70äd6űGglí?b@˙Âő[ş˙'.»‹Ťçź*Ţ]ěM]¬˙‘‚ĺ2.`Wkgŕ?Ň«řnfRóŻÔĹěüOv +âţGd‡dńü‡)ăőÄ×čüwŤ*żoÁżŽxÖ?gÂ˙=ü%«»:í€Ú6Gُ(šBö†§>+ä|fč!˙ůdřŻÔ®–D‹‰=}8!‰Â/d- [Űď_ˇć_Ô] łë?ňď[zÍ‘—Ŕ桶iÍáţ’ES•đÔ|̧ń…uäŕ–3§:I%ň·)€"ĹA­Y4Ĺ`~C˙” P©u(žýóz[rőä­…ę»SEtIŃŃ<-fÍŕ,ĹĄŔĘĎôGry…şeś3Yí íŻšŁÇâ|ťÝ÷±ě/Xש•íß ŕ=JćŘZpťí±=—0‰»H–¦ş ]_îqăcLż.3Ěš†ăŹĘ˝rěíĆÔcL+ÔĐ95ĚBĆĺ÷uÁ‰řčHÖ>4=‰‰Ĺ[ %±/nérgěüĐÍ?]Ô ńy –î~î|äüéÔK˘9ąÖ"ĺĆś®ţ ŮŇJď1šIS¦Üö“äyxüÚĄwŕQ)M‡řřSeÎgV¬ő—Ř$Ć×h Î  ‡*Py‡D6”ŐCć“äm\§©mŹßmrżď·ü§ăěúMŞř5"Lęľ÷i$™™(‹±I ÄziZŹV2ÄđâtŹQ˛Ć2Ń[űó<~T_Ú©ă :Ľ”MWŁi•ĎŰzl¦‡Fmhń©'ÁěÇ>Ť·UT†U×<đ›öbÄtx¨ŐOúD\ŽkÇ7üńćďÜhmlśîN?>f*!Í@Źqx  Şţ”ĚăĎt#ZÝëHĘś]UHˇWě—Ű O[´GŐĽšLĚemś€Ń“śŢRÔăłÉŻ)Cu',Z-8źżQVÚĽEyÉX†©ÜÖ {oşsPűč2…G xăˇbžEPÎP :·*B1- ńÇŰ0ÔÂŁ˝©Ú8çý*ÓŤVŔtHëě 4­—©ˇrv#T4ć}ʦBx¦bÔť»fÁ*,×{V8ÔBÜ,ÝrFŇR”[L°´ŘŽł‰PG]Ĺń3ßç‡)ű˘…ČTŔ‰Í,ü˘}ń5ŰLL݉;ţ±ąń #Y5Kp¤Hv¸‡¦+SéK÷¨Ş´‹-ß\úE4 u\m\JŢeü“Li0ž9öóä«ËÎa=‡ţJ k}±Ôű´Ţ6T¸źH…ňú5±Ŕłó´Ýű`Ż_҉őůuiZăšl\С^Ť`jV…M˘ö)C\NîtŁS×B6™ˇF«—ť Ć6˝^yK Kt-ĹGvZjçM†üsQzGh/.rQEÁ–(hTŤ‘$•ĹźŘm}ŐZĎĹß@gŇĐe)VRâ”QE¦Vˇ]"UH\Úţr!'‡`ň]ý¤¬`Ě,çJęcźÍ©lŞ8¸”¸ZX™®€ű6ĽÉ9˛×'hvĹí }ĐDů„†F$»Ž˘ű»’qP·Tčą"ňřŃŘĹMöĐ #6}ô¦ąÎfÇĽşQ1Mµ-]¶µˇž’ 19i§e°čsć§7Oh‰´ÇźMŐ>˛;óëă?#Sę¤íůĺ•Ţt‹Áă—ÜbŻ€‰X¨˘-MÚ] űP#JŻąF¦X˘ Xëö<'C™®˝ĺÔ!Z×Zjě%žUőé~߂ʬ6jí`.˘ŠDbSel­–ĄŐ…EĽÇ@^? µIä°aŢrhuŘ̦ňWqř> ¬ŕ4ňŠŁ5 \â˘LŤĄ9Ý~i<_s5kSݬµ eH®z_˙˛čY٤ů¤zŤ6ă(!ĺ!¸-Ysß2űŕcĚZď0şć6€˙1?>ŢŽż`ť fí9ˇ8¬\ďFĄĆÉ;nźŐť4Á*CQ'›q·6¦úg{¤•ĂŠ·XÜí„îZó/‰LĚ`•ű9Aá—·¬Ç¬q¶q'şä·ICß[lHgAŁ(I}Şť«Žú€-ľyCk{˙ÔÍŇŇ[G6ś¦oÓ帛ID÷"¦m˛/BŞ^í©sýŚPćźŢŢĄ ł?ď¨2ZzF!• Ľąd¨°Şg¨­â-*×&Ó8+[ÜÉú5Í"şđ“Áť>Ž5ôg-N!>Ů ţ’\Ξ°t ”§yá(/´.SŞţ8A+ PŁÍ‰?˝24÷.ŮA8âŁó˛5ůä‡ó _éŐsRď8ă |Šeem9®?2Ś[ĂżAüÉΑÁEĄĐŤ]|5(xßµß|­ĂŞéţb%kU;µŰ8Ěęcá“5ľl~đAjW=ËŤŤĚ ®7„©wßÄf ô˛lVQďÖzEďĽ®ŻťˇŻçÝw$´(`c^…ľš˛äąĐrĹ!ČĚ-(Ł'ô ö@ŐRôŕ-бóĂ’_lŞ-ÖXVkĘŢ4řú˛Ń–"sĚbńzyjŃŇŁĘ[eĘ3‘vÍăuŞ].;ň<Ůč xĂÁYY‚˘5eHß“ÇdŹ6KÔ+Ż)ŞŞÁ»uăЉłE¨QČođ C§îyr~|±s9u;%: ,$Řľµ´©éÂŐ´‡óczái°yxJuvGŞÎąjßvÂ$uá?Śx:Éí˙tŻĆvŠ $jŐąQ”ÓÝ1źE@d6—ăűŚ\Ʀô@Uđ˝pŃëK"udĽj¤Ś˛…Ôë÷÷|‰j‚‰dşĺ.,użtc4§¤F’v_0ňO}C˙6ýí P3Đ›?.I*ܶ@ą(Í.Ő÷ÔďŁ÷đňĽÚŰsŐ$8jŢ*…Č |<±ĘIŽ›iä´–Î@$öe1x5˙,ćŇń6›y3JĆQŇÔT2Ú>©Ŕ„ÁřÓHÖ>µič… “éü ߌłO+±o4@ϲ1ćę«ÍF+ég‰Î™KT‰Ţ ŚÚQ}ÁńĘŐIgź±\Z0/•[DSŰ';łbâČÂÎepĎ­ÍËšăá9´’śV©aÖ˘ŞčJđTÁV‰zľ®gń㋟.¶FÉNˇÉÉ}[GśĽ¦v‘»áa ¦üs§ˇ©*ŚŤŚhů›ڱz~ĽöšXÉ›jđBNîÁÁţ'l[¶xĽ†×ă€%çůřd,XťńŻĘ‘ÎKĐÖŤRÓ©¸'Ć$ů–‚ʆ·f†M¦°ĹŰşĄf†gÄ^©¤Qxˇ4łWśËVůQŮ1Š˘z eŚ}÷Ą"CŇߨ$Y;BV…lŇEäT(_|óĘ‚_h˛ŕNt\x I4Źe —0íň3¸Đ Ä¶á®gąâf«‰ÍŽR r—+ ń,Ú1ăĚśú~wťٶúěĚŃŻýnKň:”u¨$}Ź!ÝENµ©"QX“'ŰP9Ëź V¬"´gú±l1Uđ¬i‹Ël?†Ś:odÜńrěŠY&J„‚dÍ؇hßŔű­-űjNĐBÉÇ,’ŰF•Z”[°ÓěňŤńgŰ‘g˝ľ:ŃJ‡ąé¬>*ü~)*@5ŚcĹ㓬{ÇĆđ ¬9=ľgŮ2ŕŠ.Ě`Ť`ŹdYŔ¨šĚČŔXÚCĎj 3P´Ac~|¸H$ňˇő܆˘ufŠB˛,~’úkÚ Je?¤ĎĘřáx׉ ?dÓďeŕîí´”î9Źqs0/ŠŐ§ŽYVÇ+ËVLů*Xq”¶?©…ď‹üTŘUH ‡áž`ˇNG¦@>Ë‘°ë7ř[Ô\j‡®÷Ń]e»K7±±C\D9¦ˇ˙>Ů CBÄ-y‹zlaňÉŽc;IůŞi5ňFovŻ«Ćxµűx>†©đ. µKµK"éľ(]čăó·|”Ą0€¸&ůú6CáţĽ[$·C_(ó­÷ĄôÖ‘Ţ˝ŤĽ5?s›W=ŘG\›¶^łR‘ÂÍĆy śÔ,7Đ śß=u:ŁhŞć[dtđy)´Ýž­aS =5¶Ĺ¬Qö/źđĄŞęoµ‰™Ý§“ăx‘ÂN4úţĘ~î•|ă%’ůi>¬˛™Đ„HÄpçÚ8'¬,ž“Đşú€’WO3©ÉyńG_bH„•‡SĐ0z8˘WÔ 4i™«ż8“;¤ŹŞŇČĺ|§Ô őňőľ@‡ŻťĐM—nKꍝżxÇO«řđ†ë—`ýDÖZŹE¶wv|ÍdÄë2—Y×üÜ[^ĄŻ«Jý@k»Ŕ_űíŰîk“ôëo5Ľ&>ţ•Âľ§)~Ż× ľľ}®ÓÍ'j˰ŔkY¶/jíś=° Ë‘˙,_4 Ý˝-MŚŇśO‘¬3ęđdh¨çĂ…Ľş8úĚiĂř:ÝcOĺm'VĐ~…>üWIY×dmŰV/łÖŢĹ#‰PK° .0Uâí^CŻäĘv3vś}‚`$ö°…tAÖ"BđTúß3¨‡î;kNNŤY#»,×­ë٨ňšSŐm¨Ţ}Ę×®cĚľž2‘ gň­­Ůő·oęyk„˘ŔK;,$”+#4ž©ÚńRźß_ŮęÁ©D‚wwÂu.ěo8–#8ňÄ S‰‰ThWaÓ¶c‹żlËőóđމAŹżm;ÓşR©Ö‚BŁ:ýĺ1Ý-#ßsŻ_Äo;B:rCv—µĺ/ 6' ‰ěÎv&‡‘×üĺ`ŘÔ9öÓ™ć nEŢBO·~[+A™ĺçž«ô$'ŮŞ_źĺ€+‹˝± ďYĺôő—9dRH¸DaîăÖa.#ŻĐ¶âĂK Ýµ<„˝=ű[Ká€s4ŻůűČ<új"Ů© ŹÁŽDM;{­ş¤&)9+›ÚY1N%~űjKÎúü–LŹ„7e["ŕ¦;6cĎŹíĆkő&^Ţ۶$*}˘6zíżĐC㞆Zžł%tăżDt ˙VČŚ´­ý9Q!…9·“'Ô›NĄŁákćľ\â§*"Ĺ҇WHäç~ jčŘż®Ą/×Ĺń¬…Šú‰}D‡rËâţßčň“5że:BKXI>)[šIT|űä3śI*.Ó‡™óĘ)>Cč×E%ýşź}˘Ś_ż'á0µfÓEëö"ÍÉ7ßI) ­L ”'}6ą„Lă3ţeg ·ŹdË;ŻX”:%ŕŹĺ#;ŚÓ.e©ÇYˇ3Z 1¸#ź[‹ăěÝgöiY G4—·-wË­ž÷ś)pˇ| Ű{4s€nĺSaWŠűĽ ç­ńťąÚ|”´3–şúĹ‘¨ű(-ź3Ă)(żěbĄŰ.ßÚş~LÎĎ1ŮúđU†€‰™,žś^G¦lËH—·^{Ţop÷˝ ViĂk•ŚZČ~ÂŻ”úJ([EĘÚŤ?ßë¨AUx'D?ÍÁ }ą„7?`DXâÜčRŘG>ǙޫcA ŹSFpŹwJŃNŘV‡w=˘ËĎ´” +U´Ď=ýÎ&<Ą,jlj6{0@đýÇx| { ýó™°…Aڶ*˝‰¤pŞ–ŚĄĂŠ0ĺľź5€fçbhľD'¤7l'éßGcďärR îCJÂx'ńßٶUÓx/łČ­2$1¦dü(·Đ;Őŕ3ĚPć\”cÎhŚ"Ź-ávń˘­ď™ť–Řŕ3ÂBéOĚ~¨§Vě{«ę.‘ô‡[<#Ę‘Ůî0=`ůîß ‚oěRlOQ[žę6d=ŻĚdDň–ŕĂ+®‘W–%†÷‰Ž%˝ŤďJŢ„ĺŁä5M2_Ö7ĺí˘qR{ľ “yćĂ{ĂćŠu»Ř÷ŢR8şh4Ńc‹N»Ź‚Wu—0uôĺ»Řţ,˘«Î„ŁžÉ8ű‘//PM\Ě‹%ˇÖ2–ą”ěńhmť¦·ý0TÁęVĹŢh^˘Đ˛×X۶¦N? QâÇŹSîφš†ŞPŐg)6.S7ËĹ`C)Y*ß×J¨öçű±Ěß[cĄĆ§0cŮŤ« ©2ö]@@–y#źç70+üä»Ä>ÜĐu°N°™Ŕ­Ĺ®ĹŤ7zýxµT?ăýţ‚®c$bNÂĽ%Y<„ř'ß´č¦ŰŤg&gąŰgF­Ëiźµş÷ŕt­jł{ ˙*·öq ’?şŘdŁKřĺSße¬CIOÓrzšLßJ˛Şîőgw{pÂz¶+ň¬(Ĺc”q|Ú¦RĆ3Űř;f`ę;©’®1şTžź˘•b¦wň‹hĂę0u]˝Ę»NL8Ä$†qťÇÁ(Ѱ«L„řć'ś–ý‚đ`–m›Ü}•™oL“° Iżˇ,ŢEË30@ťKńMł(5ś±Ľ"Ą¤BAĆęiřžýĹiť¬b">oëʨ›Öx—űU¶Ă­‡Ë±‚‘öŤÜRqđ¨”fA˝ÇĂ}·W˙YÍŹÇ=ď ·mč´Bxá®xüĹŔJ—äJč´n™ćřjŤ¨7ĐČht*öí1ž­9Řţ†ÍoĂÎ̦2§ÄK?”PŻŐ{çÄLmÍBHЇֺ=G€Ř¨3×7«¸šÜ>O;Ă˝çWd{ÇĹ» ˛×2ëíÎŕ .ü źÜ ·h¶·öRB ^ ŁQĹ<•G)č9éżźąJjŤ,wr°´\4Mk~”Ľ}Oç®J•›[ř ě:Ş@#LżwÚ]BKŁ}S”±}vZ Í*žĹ«ł’7ľ÷Mîî|ű§jkç–Üx˙ Ýc*ë^ţ÷U-î‘Ű?( >Ąî~ç!#ôűüUc*'ËÂĄžÔZűR@´eířÇCz3ss¤†"WQ(Š˝Ş¨Y´6ÇF{Âó’Č˝_-ëŤTO=š~·ňě€]-ݍTG÷S€Útps fYăę»eŮáźťÝ5r*ńy°cYk¨Ł0Šíß=@!2%ŞUŢ)¤­ŞA˘™Ź*Ü…Ő?j)śę5a‹8>"~ăa ľízŤ8Tyjw¨ĺ^P~›Ň@ş(âői¶ÚÉŇS›NrbŻ„Ľ‚®úÚU®Ł&á'!Γ8Ćy‹‡ő ©Ď¦kMĎŤŮi,ÚČĺ7 ¨´*ańqÎî*ĄůGu»hÖ Ś&XŰ.Ż˘ř Ęô±R’äĄöČoŇ_ź±»DŹňú¬ź’¤`›‚É;gŢ-ÚŞ˛qçń°¤ŕZF˝=>@Ć–$ÍÄ]Ťż @zŠ:Î:ôb.çɸA9˘fÇlÔď ¬tÝÚŢö §Ő [+Ŕ긕~¸<÷ß#Ůi«ç{i(`jqĺP;‰Ůćä‰~é»hąu[ěŮ_yťo˘ţ˘í5o<Ś˘ňRG‹sÄöh¶@ň”ČHWplË@ĆHu܇ý>ěö”M]ĽÉ =YéÉÁ;&ţ*đćmĆCáA%ggd·Š»)Ż0VA%fŰS:‚W­.ÜuýNvBůąÁę ďő呍jGŠđcîmY©ü·ťŹ6~‡9nŰDŘw"Łg“UyL©Ů§;šzG§Ňt˝î;7Ů\2M…ź©i€MŚ+Ô 'd&RO¬9Ô˛g”$˝ëÔăšÓŇ@ ±ţeťÎĘL F謜ńÔ¤3ÔhŠ—/ÄáŇĚ/<*Xr¶WçHťvÜöô˛Ëc(-«55Ýěëí‚cÇ)›öíÖ_¤KÍccâ9ßĺŻĚ,q´;ăqh`QăűßѸ®»$|©X3ů¨xďń^zZŚDµ· ë …rť^ż$ŽĎÎnřmíIşR„ž›¬×5űđĚ‹MĎ‹f–téq– tüQFźYĺ€=}gíŔĚ­üű‡OÝ{)40k0D©xĐ_*ĽÜÂ8ĺâ{“Ď_چ2đR·ăm~zxDř:QYU#Ĺ“¶A®­˝­ˇÇŐRÔ¦»3®Šq®8 $•âs™ËyąA*— ‹€_ÇM>é·R5Ç:»ĆÚX*«˝™.5&Úxź{ře\Ë:ţq6Âŕ„fÉÖÁ]NoĆ#‚fůű]~$Şó{'ęy"ţ€˝âYwôć™Vś=ˇ¦îŐkµf×qZpÖĎUÁ#N,ÜŘś´ţ‹ÂbFĹ›clź„÷ɶžČçô~"´Í®¸Ń%m­ż„cĺ|8him÷ ĂB*VçwŕČ5Ö|aßeŤß·ŃĂH}›4îrźDě•q]Z6_7˛ŕš3—|QČs÷ĺPe-{ɺϟA§V¨Őî.nĚ„jĐÔ:ÝYý6¸ż“Vîík ݱnÔˇq!j+ĺ ë»Ü¬ĺţ˛]ˇĐĆÖL¸mśĄ™¸M‡‚5ˇŠ rŠÇ”¶íB6bŞŇé7=fÖ8#OOę­}ňť FP’Ě2ߤݍĄI´’ŮNJ¶YÂ]ÔÇŽ°™żŢ$‘ŹčmW­Öĉ;€fg\•žUÝů÷JS5WŢh ' %ŢW˝u.hÄô‹,[űçDé­‘]ÉÔš%śJS/‘:dŢ>ěµ!™˝˙Ź´óăëŻQ&RÍö (şx®ŰŹś¦Đ#/×č,ďZö (â}í"–ĺKZŔNŔ[RiŤ Řž.ŤŢ0S×_¬7tv˘ł ±í×.ŚŃ!­RďGŠWŻŢ<­żsyJ\ŐĺÖ/o\Kx«O/Ž[µ5v=.üTˇě5iN5qđ9›ÉăɰgjWV-Ţ tŁ …Cš­˝)Hž36Čĺp…ţ%i›cM ^uÍčůÚC´áAsîwÍ…6ÄĎ…'qâË}+W'˝ŘŘCŰźíśW´cÖ reĺ%„´¦FămÖ;oÚů x`ě‚[ű6×?`˝ŽÚyçĆď±Ĺz‡m Vkćăę$-k/´KŻôZ¦ňL!ěžŐÜą8>¶—d|¸HHëč‰ÔĐ”ĐFćΠd‚»Ó…ˇY.!íźeý/Y‹Jr:I×ĆÚ>§pŚ“ţXx÷Đ>äp~ż„©Ś‰ńůÚ:ąĘ®*Eăđ‰g§P[âňŢ"Ĺě˝™çU¬¶XAŔ/\™Á]ü¬ˇ˝§A-5¦—xë? Ö^GŰZµ:ć÷Tys0ž“mşńÂű ]AŤ6˘B@₦öCY/h·SřöÚ’ułu.ĚöÍişŁ[5ýźTLG%ăąb­8M"©ň-í/¬‰Í‰ĺŔçög.mRi¤ LĘ9Ś?Ż–<·ąĺ38„Q!'ö4ŔŤgME‰ńáƶĘŮő[Kő~Ąg^dŮ@¨/l'A»íK•ÄćKyô9ޱąîK¶ÍÂĺîŻ?_ůôił÷9TAA: đÇëT8ňŹ€¦Č/¶ź\hċ޴wŹqą˙ů•éç–OŚ|sŕE]'©ŐŘ źž_‰k->vëH¦á·:Ől5Ň+ő@îĺC§z1w%őźVž÷_’ŰÉĂ<›EŠŢm¬ţx˙ĹQA‘ŞČĆNJ}µ°IĺÔt C‹÷ie{ 2‘ Űń'ăíÍ ­žöb;§1_WŠĂĽ±?^O„Ó§ýčĄ1haćĽĂ(IÍŐ‡pgĚ@3j ëś,ĂÁîÎh†Ęaű˝¸Q§\úgŘ~ž÷D˛§:­ű¤¬ŞÝ9!˛ŁĂ¤hoîĘć=ĄçF&«^’ľ ľđ`ŰCĽčśnt[ĎkőycŢJG;5,ň.¨iĄVTIŹŢzT}r:/÷Ú÷Ç §%¦¶BÜD1‡ ]K¨ń¤ëąÝŤÄĎn‹-›H"Ĺ$R—dRÚ0RŐŁ-&‘/fÂŃEÔ)˝řˇ'¬'ݤűú‘…_múö¤ć\qĺľă5Ǥ& *!é2tĘĎLdÖď};Źę{€a{tĽć×°ĎěaµgKľ·VÇT?4uerß‹Tăf0s¦tě°3ťDë‡5ęî„ÔZđä°TÖĆy "jŰĐs˝˙IkűNk:FďiĄ;®u2Â/C0ľ‰.J°š q­ö‚†‡'ę)#í'‘î±+ăŔíűʤVwŃ qÖRQą= ThÄ›ž„ořőAóCÍ“÷šŠ6*ŁÓÖ±‡Ń‡§%ä§'2žd2/<~ť’#ĺ»V×JQtvéfu ÎŐVço¨şĹʶ]ÎÔđěW‡ň§‡‚8ŇŹŔ>l`č†YhÔ3ôR™0QŁuŕŤfÁŃ[>÷‹@čąĆ‘x×KĽ(Ďá8üÍuĺC‰ő¨X ůľăŹdç^€•‡b s’úa›¸d[ڱ×řána˛öČשJ‹ŻŽöM@Ë0˛ ‹“CC¶Ć=*lĘz‹űOĚs­´“”×â×ñI¨ŽyQ]|YY»s¸ďx#şćĆSĎŹËOš\>žşä¦^ľ˝6ů9ţÜŽqő+ýÁiŘ>C˘©˝YýfsQ‹Súdx†đm.Q—Xí*c©·e¦¶ Ó`Eŕfő8ž•Ş&˙‚¨‘ýA·A‹ć±e»|›ŻŞ]Űôđʱwbű,Żóm*k¶ś3ž7q"1ÍI»)mł3>rNf ß;0Š0c”Ť•–UżĆ­ľa˝ФŢů'Ô5i¤sRîŰ« Ă,_aĎ}ĺâţP>%;Uńş§ŰÝÝ÷ő⍲F%ěŃK#•¶ţÔ'ńU8ß çÖbeŤŹ~¤jéK”plAÔPąKĄžŤ›6Ó(7qűBĐČÖ&ëaËN‹kôtŐD–é7LÝŞ"¶J°JńĹKƧ•QîRwoÖTÁŐŻ[ĺr‹[ú©Ń𑚶§żŢŤd÷PS8 ÄĆîä^8z†Ţů 1}dˢľ*ÝÔHC ˇ0±€ô÷ŔnđúÔcŁëć{ěź ďs(űŞ]Ř[ľ ‰wěŹnJ*@—GŰú_¤"p/-%cáp~ŮMĎźâYćkq^HÓ×aĄQJ2·ÇÉ@uÄőPßtoi4ˇîJ}ĺďáÁ.[úß‘„yˇĺňűđUůw÷.Ű"§Ř˝HG¶5aUµĹě,¨SÜ âař?ŹPîľ3€Wý•Űę±Eű%;&8¨đ뽹”â•zleŽfΉ•ŕHľuž PÄ»™÷E«s±•čq ÄĚ˝7˘iđôĐÍXËôrĹ/Ň/CŮ–gĐ­šś;Yó_жń?±K0˝`äI :A'au•Uf‹<őĺ-"†ŻÍ–Šé}+v?ŰŘ22gCŽŢMédaAŰŇA,x€ŹQĂÖOç3§ëĎL:ňă#sIđMů– OTfÄľáöçŁŢ4®Łď÷yŹ3¸Ăë¶Ú#Wçeφö’0.Ýń5śRC›Ł7Ľö2Ă5 Rň$hăň•*wßaç¨(؉éuŔĂŚň2ç)©Ĺs(9ř]Z퓣ü+˘YÂ2•Žů›˛y»Ň»ö8dŐ3Pç4‰ŠőČhČĐÚ÷׌6’Á«=ä“[äľ×ήŃmăîËtDďć E˛ř Św3˝&’łĎšő±Ă źć(ŇESH…Ӝ˙çb0Á“:8VŇ×C‰°)J†¤§ŻÄćX‚ČV;î .śjŤŰ’ŐĹí8¤ĹĘ WÎVß~năĚËNÝi7´ń,µ˙‹5@.Ěeí1A»»rzăv¤„äs`hß Źl@4˧‹…oŠ2„p+Ć7”Čś ÜŚ<Ľť>އ5<şÁ4(ăŐŻNŻ 8GĚÔÂĎ3Ş1 Ë[ËţW fÇXšľi´f¦äĐlŢŻ)iE‹6´7"c»› áltGçlIôqę(ÂgŁ+ń+\Üawôp]…:IĐGůĚ~>^çe8Fç˙eGˇQőçÇżč‰ôm †ż˛ú.y]M\Ěěý'eţs¬§Í×$p]}Ó5Üęűň@ăXÇőŽĹµŐł”;»´­Ł%´Ü ő-g“=ňľŹď”ĺ>gz/¶ˇÎsŔk^zm:V.Ť«hËln‹S•H¶ ŤĆOU¨"Ôxáeń=äÔ@‰°`° UbĂr{ő'a¦×t©ő˛ş´ćFS7v9¬§őíw×çď]^U°0v‡iĄófŰRłL“–9;bTąˇ‹¶xĄuh÷%rĎjś]ĘGďôvó»JYĄJS4çĚĄÁ•Ń|ÄŻWĂSÉpŃÉ Y­#€vîoÍ|—IM$¦«ŐŽŁMm{HE.˛(äĄ$˝Ş»úN.ę™!Vj¸Çöµó .ň"jWYą•mČľ˛ú)x@ÇQ>ôG-Ąś×J Y­Äňfě™č"ÎNéۓݟäŠý~ÚnJšě=ôˇŇ'“™Q@ĹaôЎ̲řIB˝âÓE˝ÎÚň—W‘7­ť˛Ş—żö„6]›î:˛–JĹ•Ý=¸Á'ß÷{§ČĚ«Ž+o*ęV*: ء &ďD•śGÉ—Á#Čűľ’}OBÇź+ŹĘôĽeH«[Íź—„ űFRń D‚í¬ŃĆý y㯽n§rF ĆóˇLKB–â—Ü4P+“jńM=v_{¦ň EŮ$Ę;ÝĹá§ ű…zńYŠ4QtN\ňĄÝúEsHđDte‹k””\h\“eYD[ëżËtŠ›-*»Śí{ú·~!˙n±Ó&¸‹ť Ő/.‚Ü`5 ^·žÔąBĹ9®›?Xv&”ŃéNí>~ňZ†öáهµ [µďép*÷˝Ý3j°- ĽľSö‰Í˝žm“ÖÖŽźĘRϪܢrw1{=‰•:bЇíśôu gˇFŢ0˘#j7+kxKĹů faoţD–ÂühÚĹ_“Fě˙^;:41É݆čô•Á\)ú<ó]L¤0{:3ô®sö.vú‘“Eď ŐgťC­gŁĎ‚ągĆ~Úţ¸”V­ Iý}·ô§´=ë®1U“jÔ{<4÷ŰÎy°üč­;¦ *ß;9Â@3Y™ŤlÉPy/†(#„_y˘Ů ¶i䓟…¶VQôëůLÄ ľř})©ěłcÜ%Rłţ,‹š9ĽŁÚr‘–rt Ľ;’p†–GĚ2u}–Mü<]Č.T%iB”<`‹pÍ{P/ńCS Ą’âC"K† Mu?`Ŕ˝Z×y_î>~B‹ußîd‡ş{GFĚžK¸ąúWąy‰·Zź)kŇ»t÷Ž<°Ň5ä[ŘÂaş\ˇs=P¤5ş˘ň˝gčë&Ęë¨)Ö&*v źđľ`źídűŽÜžµIźRş;Ôš"ÜšÔŠwCµ·p Żm—P‘‹Íɨŕ«F¸ \™n¨«âµP=‰—Fۤ‰ťĂ|Ţ` –L!ĚO™yÍ1Đđ5Ć1d°"ČťeúČIMÉ8e1Ż]ř‡Ú®]dęÇŹäŕů÷ѧ(CRF3“IHŐ@ÎG|oű/F@®d?j0`efűŽ` 'ZG`+ŤIŔă×ý´ýČŞş(„–§.‚ Ú˘HZjŮřŽQ5›Ë5śWŻšDăłÇć{ç Ľčrműűšµ{¬ů°]ş‘цgů±Ty™M5n\í€7Íb/^K™?ś“¸űá˘Őä A_ây¦zZôw™‡$žĹ}&`‚ŰxAë ¨WPÍ®çőr´6\XĘd…ęýŰ IđFď)ĽĂdĐŠ‰s^Áž`ś %ľ!é弪řYŰËöµĘn˛lV/ĚFW|­¨(C|5őćNęť÷v_Ô†‹* ş8śżôŘfWźXíË“|ÔµoţĐ˝‚ţpÇ {#rDµë¦YöĄčačZEü’Ü!z›ó·ĺŕňĹZďŢŹdAifâĂm‘iyé|ÍDŞ_`D}ňúÇ(ľćĽEPd©KŇB 8úTyöĘVr„Ůç(qćłÄZö źňŤ± SĚbKé@xúľl»OŻťó•Z„{ĘÍ&Ź›ä,űÁŹRÜxĄâĹ©1Ď@ďrÝc–éĆ dî4úů!Öô›+ |˘†-6éĆk’=¸H\™÷V>lłăă·h]Ăý%1ŚA§‡G–µvGQ:ĚY1渨aéçŰ‹đrÍYuř/g†“‘Ő4fv SĽąX†ż*$AÓ«Îchľ?ô+W멜ľcqĽýŇťVŕ sOćŢěDvGFŰ·¦¤÷śţ%[3ĽičCőđŤ‘€‰=Ęâ• M;‡ËËŔ4¶;cíč/‘z݇p‚ÂX&űIş'VVvרëÚe„Š/`Ą;7ĺB#?ô¤†˝Ş´®, â»Vs˛‹¶`MÖ¸!2|609´F„…ĽćZá®mŃčO]‰L>fßa‰˘č—,ë%yLS~˘ĹA”OŠpü‹Ă~l%»ĺÍÔé˘J “\nĹ8(AGľ Y_đ ·‹äOôúŁë𑹨>4ŹmÖřa+kJź+čłd¶t@9\g ŚŢÇeµbë@€‰ iŽęî^ł”wuĽF±6nRÜ!7n¤!'óvR…۸CgĹü±r\ńóLF&cÇ}ÜČl:ěRőÔ¨ŚMKÓ̬Xľ>‰„żŁ°çÍVm©0?ýw9kíʨ‡úxXD‰ŤČɦ`ňťđÜ.)»säĂSq@Ńhw !}°ăq‰˛jü.xńé^ź˘!űˇ†hć¨]Ă*dIo1<–¬I_9#˙Z˝Z´W(1Ł”·ŮcÁŞn ÂłD”Đxřż Ó°íľ—RHʰú&uv:-RuÁ1›Ł[F-łX‰›«óC ±‘n/Î?ďnIiľ.6ĆŠcńé; %›ŐBlĆfěů·hŮťôąĐbG6>Őâ›áú um f}ŤÁžĂ1 «SŢUśCUëÔ ĽoŃ™čw Őű`IMßČFż©:>¬!4ű_3s­·`ă_çjµL˘\>Ř÷#dě(ŤŁßY-%eŐaâË!©‚o±YśdFňÎRąmŢÂi”<1•$üŰ€Ö‹® â‹P]Ú*!Şfꤑ¸dC;‘uŃAGµ»h[ňřűś˛I!4­ ™_;áÔQu0_‡ť9ţĐFËŘ‚BCyT×…{»8ÎÉľ±˘Y&šD"N[ôBY(2nBí<˙µW§Ă㔳-z)Ubuom/a”FeăµÉ¶ž±‘yů`l ęŔ"BćJe’ź%u&n:đ=S.ńü¬ĎÇŐ‰#ź4<ű,ny —Oëoäx@šđ: íiŕ‰÷‘uKÂÔA:V„ĄU‡Ł!ďbťbŘ->Xsk–Z'ĂÔo_qX›b]2—Č0”ĂŽű~vN;«[ŕÇ·[Qě=ę? eé˘*vČS–…śĚw&čděn*ô"µ}NVCzý@}dÚ?A®[/rťCÓ“Ĺ×CŽˇî ‚čüśJj–a`S˝ÉOŇ€µ˝xŤÂ>_5‹U+Ň{3osűĹtÓ®bé0ßéx«5YAžç®vzŇ :6ť4{Kˇ[o–.úW«ŻĘŕŇΩýô],4FRn1Ý&­#}ü[rĆśŽ¶Żë2iÇŇŽC"źvaăUđiÜ,zô9®U×Ě nČîjőĐRŞ~LD¦ĐŕéuOÍNJą—Ľňrśˇĺ¬ŁĄÓ{y뱹 ćWńŻŻ$X{řlŞ«ęŠúąőŃiĺ#•řsÁŚ+öłú©âŐĺ`őÉ‹ŚŇőëV5=Dů()u…pAÚ­@§‘ŤKq™Áňęvl3ŞC´TD”ˇâ*eçá-_Ż…Ęg–{C×G˛¸’¬tÚţId‚.FőoJ‘ד ¤ŁŁŰ•…%¶©„žŘˇÚň'wʎ,űb “µˇĂmĚa­ŮđQŰ„Şř6ż‹ń'lľ#űÜŮą,%ő‚«ľXĆéó§"ݨDŇq\¨Î•k±Ž'Qőä_iŽěŔđZs” l.ýŔEj ^6d˘[ă;—C´0cŁî%ť§2Ę•*nOŁĆŘ|AÓšF–› n˛Ź—!Â>3âZĹź6:‡j}ŔÍţf0P X©pcĘ„“?Ě#)Ńq“ëéďĐó傢ż …p2˛Ús'tc‡©ĚŠ‘['ÉŇOŤ÷ęŢfÝ”H–ëýұé}^ óŮŔ<–řAŰÎLĐ›ťčxđ΂wB&…áŽŰî9˛2ë(ǶĎaŢř§‡€Ű´U&Ý&âťś\Gă‡9ĄĂ%ŤuAúany./ŔçÝ|ţ©Ů÷>Ä!5é ř_Űż!–ŃËŠp.:NŢ~3ŇĂüęsBN›Öqŕům• ĂŠ¦ó oŹk‡éř§Z|;/—őőŽ´Ż–.ę}”‹…•@D.ßÄĚÝéĂc a ‚ĺíŐ—‹ÁÉ ůĂőpg€ěZ®-U(NŠĚ}JGŮľ)˝ĽřVęÂň’}Ą¬˘ÔŹ ÂţnŮěuŕ`·”‚čějMłvŔ¸–˝ü)Ć‚R)E+ ^kާn걍 ß.-Ż®^<˘?jăűňą!.”ö!źţ0u˛s4EüĚ•X¸I u†déĆ>O›ĆĐő>*0üŘôTľ Lý|ďŰŕ/–ć1#˙ Jů‡í$¬´hÜaJ˛Ňd*f ‰Pż < „(ú #ľ˝}«‘Ŕč"~¸ÓţZ‰%'î¬éRЎü¦˙51–H{ůWu(Č9Ö¸ —f<u2NgŐG“÷¦qÄ˙8‰îmčěą|Ü4n&NeÇçsý´¦$¬…ľ‰ŮĐę‹7 *ĂqRڦUAËŚVn3ľ!’—ëíI1“qSe¦ÔMŘ.Nĺ'­Ŕ‘oWQc_éŞúśYß^>Lmky-<÷o|~#´®¸d‹0‡DĐ1¶ö¨§}E2ŕĐIrĚq¤>~[ü¦ Łżccý•C"šđŠŹŹłí}!ĄŕĐ‘ZlAfMâčvX%fŻ4můőü;Ä®Čű„wµ2rDť?xńb¨+P "îĆ(„;GUY~Rôß} FCĂ’faRňąy‹P2Ý:»-?D踵‰2ý\Ŕµ$„Ű˝Ńf÷.ćS0ĐŐ‹łÁŞŰĆł¦ ¤]úćý1ŠÂ· xřcv°ŮšxJŐ±śBS'8Ń ’ű ľsÚPC­‰f{l] Jc+1ýýŕ *óËR÷ßW»JŢॠyöĺ=•Něygt\\|ł+żď5Ć{ÜÓÓV÷Śë‘(ž;G'R>#ąŕťGś*p›ţى̳·+…ąP;ł¤äŢłGM&g´-±řđBňÜk…Ľ¸–Gśd÷đ×aáX).*8ywĚdQ¤ü‚¸.}Ö:çŻ tcą ßŮÍ#h÷RCµĄyŢ Ňp¤?݉e‘„•«Ý)î̻̝ JÝcy˛.Ôa§I¦9«µfŤl>LŹ’ZËĎí­Im…»ľ7ÂŁârR˝^ĺč5=h‚eŹÓ:ĎŔýţŐéV<#^ ×€R9ń/ÁĹE˙JíSŮďţÚşĺúH[7Ś6mţ»ÖźÇü«ŐOzyLäQ‹şŇ‡«‡ô K¤<Ô:že!`}ŘE!«yŃ™.ÜľZĆ 7.äÍßP UšŞy84úa>^’Uh§yşç3ĺÔ^Ăś śÇaĐUŐú«I=z®0XËJZđ뀿€ďńĆŹĹü­ ,AxŘ2jÉ#ĂÁ–°(„ąU?Ťř%l‘ l¦dď ,˝˘y»Á Ĺ˙ ¨ Wó'wý“»…<ă)p~0žôŤ:pŮđ”. ëć˝ŰËY;T%"ÓłđŁ0Ě#UD˝*»”şőiLQpľpţŘ#B|T‰3·­Ú†ŁNc˙ĐLö€•5?Ĺ[I'©CÄŞÍm`„´2¨v xÚmĚćŹäcsą›Ů°EĂ0ć©ÎoÂA˝yVË‹g´FyíA×±s¸T9aʇ7rÉ1Sš±+űE’‰ýy·ZţˇŽŁłáiŹÚ‚GsŢ­đx˛ g„Ú‚†ł%fHw‚|ör"Ň8€açĄÂHŁË[Ţż–˘_]đ1ŠulmĺŐ}°ĄÎpěÁÜô!äq2Śě÷XϨróýs\ëkĄ Wo¨ĹËK‘‘öţa® d[ps倿8Ú´]—ÓĘ¬BäqWk\8/tkĹB¸éx§#éCÉ5ůđjrt=RX,ŽÝcüĆdř$hľ{pl9Á¦w 8DHl{‡Č‚¤öâR  ˘(LŐŇ(KŁHě8“‡MgűVţŇ.1÷Sďa彼°űŢ˨˙ĄŔ´©Ćśß]Ý>măn~XśőŻiđí„d“A¸ŠéÎ ć9‡C±žá¦k˛]Af8WĆă4Ü>:\ĄT[€Ću˝ďz6ąş ZŔCCľjĆĚIÎÉáóéa·ĚćË121tFÚ}ÔZ±7hŰ|›CřÜ1›ÇłýĆD×á“Gl§"MQşĚŘÍÝńs^ËÍŔŠđ%xOOpťdß6 :ÚOc Ć/ď‚=14TL‰Ö ©/ŰK&ţ–®7óźÉK ĐÂÉĚl7ʬC×Mág’j˝ 7'< qYI›´čyŃO·[mŇć"qÇëçDĄ]e7uđ)=É=´¬™Ô‘˛ĘöżJ×Ö§"¸ň[Ţ•śĎ#•{h"đˇP+:yőĂđPşsĐ!Ăžsq,Ć”yKbî†UŚáĐ˶X€Čßč_·ć„ł¶Ăt°aę›ËĘ)00lK×-2‚ő»Ę,0BňýŇËŹľf<‹sâŻútfĆĽ¦rHUA;XĂxJC’ć§ż×ËŞ.Î\óß¶ľl\|["-áH>‘;_Ttą9ĐÄX_^·©e ?dH’ń91ż^ť*aBô ˛żnúËĺµYŞBËşŚ5ŁŻp/µýł!îÍŽgí‘“VÝ肝TĽlj¸ŢBäLK$¤j^Ř4¨5r;”:S´ů0[·ÇäPčT·=#‹Č©ć'ĆH•ĘŚńü%dôB,vž(ď\ ”ĺŠjŢąrîC'đŚéľ6řŐčÎĹý±ëË#WśŃuȡrŞ´VŃQÔÖń÷Č7Š ăkE=·ĚĚżNÂ[.§ÚE›ĐiýĎYa/Çř5$+ÉŚZŔ÷Ď|z,i°ň˘ŘÓ¨µ”S§˛‡˝ôĎʤľäšd„§ď¦ž@EGé«éĺŇl›’É>ĆF¸sŹÔ=,@ 6˙ŘMč9se®÷E÷xŁ”'ŔŃfZ?•XÜáŇúeî§ý·&ôayA.Á‘ˇ"’đ(B´\ŰąD‹ůí+Ь7lŻ,H„¦^tѰ¬í ;Ŕ!˝Ť;ěëq‹Iň´ËŽ™žăą"đSÓTOeŃ+ǮлµúpxV“ä U×<3Ađî;éúY ćʢq–2 fŘ4ż-¬i^AčihÖ6â…‹ĚÎç•®”äšu«ęUplĺ=UyĆJĎÚ ±.Ň~"ú™ÍÍŰ‹Ů?I‰‹\ęÔkıŻ~‚Ŕp±ł§]CůŔ™ť×S#-‹Eľ ·mÓ…Ľ«7qt„ÝŹś qŕ(Ó5¬MłŘ‡ĚżSj¦B‡Đ0Ľ\Ëk9ßzy:EĺRŐÇćí¦»m CĚÍ? tż#wĽá%­Ź«™›ŘĂ‘)A6äÜ•Ě@JWú”ÉÉzrËC„Ó’uç”SŚŐěčsčâňY¶CźÇ$p/’ŰŘfzEÁČ·şŤ!T·ÇNŽŚÔ÷?úŻm¬úŢ­¸ź ·™ířV\€ˇőtE—;ˇDWB¦ŔK¤hóaŁ“ľqšµĘÄ[+f<ŰÉÉô»9ĹÉ+k™({´ćË€t Iôż8=yŘ < SŽä!¤ť\λ„l3%Ë:ňXŕz¸ĆnqEřĂY;LćÖ\żR˘SbťGš:}YoéŠČ$źßň˛…;Ăęŵlą%‚+Ť'ëLQ„ÖúxeG«$ţôŻ|ާzřłŔˇí’& ôq¸Ç~0˝Ŕ GËkLźtTu±ă vÉ{ FmRĐ˝‹aËĆ«:íˇ÷ć”ě@Ó1ę+=ć=ćŠEƲKŃ89o6üµżŤE»ă<ß=žâw}4ŘUŕŕpĹV=‹†›ţyü¬M"ŠŁŮŁ‡¶ 6BäPŃ;öą(®ÓQWp"½Wô÷q3m\đJdęOµ×WHܱÂŚźŞçČgÝT^BˇiyŇH|†ą0_·¤Ú~)Ý${ż°’GU2ĽÎşŢ+ż*ź©SAcGŢžçó›„„˙śŻ›e<{îŽ=kąÎ$&S)ZđjěÖÝyĹfh,‘ůă[üŕ|ÖłEĚ=tVĐŢëH'˙č˙E˙„5ÎS)V¨dJŻ ăvŁy±rى–ieO•¨0’ůĺxě0*\cő”7¶·›ęÜcú#IŐ˝ˇ ň”‰R~ö$¤[ř*žĐ÷¦ĂyFhĚE/ÄM4Ô {ěľn»pŁÚ·.ŹŃŮ~*Ć{e„ćXĹĹÜL~GÝ.*¸“9” Ôň×B„ѱh•Á+yŇ.‡‚Şü>‚/őcĐ#“¦ŁľŚRHK0sZP7 ä"@YzD¬Ľ34¸N,ŚOă4 %u©…Kö9§>éL¶J§đ}UO»¸îéá§0ÚűrГ堨ut?,sâýĐÔýĚâ$ćQîńňě ˘Ľ6ÜdŔ‚‡ǵ”1ü}ŞŐř?¦n‰|ÎřFtŢÄâ<Ňý•–[2ť¦ą’ËűLé]hăÇh1ŮYă7ÂĂâ0˛Éţlęâ-˘PŢ^wRVé{Ž™ˇFoöţhĎO3wę—&~}CxŃ9úŕÁrĂ„ôÁĆjů×LWü‹×ČLŇ f}lŘŚ:/¬G#«˛Éýtů™×_‘ŞCÖź:…†ţwĐÄ*z2ۦ=Ę0¸í®;Áî K«”ÔĄpnŕßhFe›Aćą§`hµöqŃřeÇcŘ8Žż üS>ˇŇîrČx[•âxńU8rUĽu0|ăTć˛,ä'x3ď$GAŽHup ‡Ŕf}Žuéć^‹Ú°¬WÜ!µO¤łÜň(cL`b™H¸ŮóMöTŠś˙5 (Q{.±ë±a[ą4Lä2€ ĺîšÇh.â:b{˙<ß`ÓÜÎl&kxŘÔCĂ5ŃA€nż.őÝÁUU ‘ďĽ?(¤ĺÉ·±vIDë›O~Ë\˛ä Żrb^Ôöž®E銄}W2@R'—˙‰‘!Ď<‰‚=še¸Ě< 9čL¸ť,,¤S!§†jYř Űjňp„‘? ęxčÖţé)Śuwőö$¸Łbě8/M¸ÇéÂčÝňĆ<@”K3­iëĘQhU›ß/OŐďçz™®1̱˛ź%E//ČP0ĺHŹď'Hń,ŐřŰÓ©°ĂíżôZ¦ŮĂËGÁĂŻîăl.ŐnO  ňQ!ń5´&\e Ęü: 8cÂĄÎDfĄĹłíݵ&#vEy)±ĘŽ‚´\ÜŃ?Đ٨_!Ú!2› d•LOŐ-»l;m!Ź—A©Đ@Šç铚iWČ®u,ţó] ". g{eŰé:Ą–ŃëŇ~FEąË đAĄ›č8>éi/Ýě<š3ľv=ćDé#— áâ]ăҰ綨ń}(!Ť(rÇňÁU6ĐAâb|Â?) ÂďlG endstream endobj 261 0 obj << /Length1 839 /Length2 1219 /Length3 0 /Length 1797 /Filter /FlateDecode >> stream xÚ}RkTSg]:y©("ĂçŚĐ¤$!"Mxż"Jy#-´!ąI.$7!౉X (•†…XĄ‘‚]<$ČB `AP,j±AžC™ µí”vÍżďěsÎ>űěóŮn Ť zł… C D ‰LAL”çI`.Bô †C\)ź)&FR2p$‘ lm}Ĺ………č ’'%Gđ–r#™â(.t •Nu1 6ĚBAÄ…‡• »Ž`<«8[*ú5‰%!ŔađŁg ľ°!ŽC°…YŔáXxŚźě B™R>…Y<¦«Ä†K6$(\đ±j„‘Öň0¤|~0S€1ýľ!đ o6‘LŮźš/_ۆł¶0‚ą<ŕް­MďB™.o„ˇů $aŔ2 Ł,ŕ0ůč|ĎĘ6|B…xĹf@¤˝ż&ÉYI$‘Şój BŘk•cvŻęvÜčj˙˙îşÚᏰ„lÁ®HÝb1Sn@,˘‚ €±Ů2É0±$Db-@$ESG(6X9ĄłpńĄ’ôŔ8HřL oůŁşP&Ś ‘rŃonD ba łQ6ó· VKţ'Ć–Ă2°ŹL"“)d2¬<Čzüu*î/,ňńĘ@ ťi@Łľ\v8§ţ±Ž%‹!]ýłĎżĆ»%É –Á}ŤĺúYâW§Q•EŃw]~1MĎÇnńb¶ý»|üŘH–Cp]çk(t˛­nĚ\v»ç@ÖĹŹTŻ"–tf§˘śşšjńýzhĂRÜh¸gkŇŕŹ„é®A˝B×ßK‘Ô¨őÚ$WőĂꞎYËkŁ›ĽŽ¸§Ţ; ŻŰzçîcsĂ×ćëebUÚrNoÎ…qh=ŞžKŠyVĚłQOČ$óévăÇ7`·[Uzaą ĺsC·ëéö†čOš·¨Ťj§ÎŃČD{-—8­O.۬óążJ °k˝¦OZÎü°ňáXyfšÉ¦/Đź¦’ŠouZ_”©—»5ů‚ÚěötľíîÂąŮŇýÇfÎá[·ž:ňnŤŰ[µÉpZ‹„đHşâÎß2VF_´†s’›dŻ,Üľ5Éő¬`Ž·Ŕ稒 Ęś ăF.Ě3ýał=ä‘`(Őš.0.čóÍ«Ó)r«DűjzóđÇ^;ŻÇŮO„gd%ŇwžŚéÄŕćeď7ANFúë§´/.ŢťIď"µzÂ}ĽęÖđŮŚü€í/Ą|úČÉzĽĺË—©ÍxËÚ"í.獛{żżšłY3'‹bÇŢWÍëĆOU‹–_á% âţĚŔŻä.ůľ™’aáaéť pUŐş˙ś–vş7úhHÜŮJ­ľň˝ł-}-őŢŤîĘPĎÇ;ţŐ›»rII$]wŚű5ôIk ů9¨ÇlZď8Ô~ŁďŐ*`r߲›uÖΧ'˛—+î76NÓŽ_l› +h7>6ÝÉw\Z(©÷ä·Eä—·ľ8SnA°Ľ4ói Éü@·öíńuFK;íÔągu9\>7Ô1ÍgbP;ŇaţÉ[3uš’›}‹/Ü sÚ›NńŇĘ٧mčóĽIe ľGć:)‚/”®ëňďŽW^y~żmĺMB:·ĄPţŕŮ R8ú8$Ęmń„ÍĎ ő^ÝEŇójd|Ű“uď\ô{‚ô\»WK/;ç›®ĂLÔ_ďW—¦ĚqoSW»%Â-ĂÚ<ź^·1¬( ü0×ÍŠďL“9]'«ÂÉN c?^˝DwŻ.­b Ő˛ŠF9?—–źë)n j’ďLs¬j&ĘŹ˝s—–Ý\+,ĐŕśxůCgľtKAŕIÓ˛`˝#fťV÷OÚňkăĂí…afn4ťĽĂÍG©mźßŚÂý§Oˇ{ˇ\”3ĆŰ5`漙‡Źíé@ű¸ÉŁ˙Ţ–ł}¶řĽţĆŰň ˘ŮńČSś¶eĐ™‡Ůú~ Íprş×P?*çnîO–Š&ŽÎĽŢĽf¬u÷ĂNNź†›ÔľńQĎ öČsĐŕŞŘł;¦<Ţú˝Ś8ëĎi‡Ś*Ô¶Ô·-H·mwŢv‹‡đSÇDM{,1HvůĐŮĹ·íűża—” ?ţrj®C/öUIŹS–©CŞťj\8®PBÔj®ť˝ą×}ć#›H\Ôi¦§°^1“š> stream xÚí[koܶ¶ý>żBŔýҢ°ř¦Č"ç‰Ó¤Ź¤ ě4'Áx¬Ř“ŽGÓ9IűëĎZÔĂ#ÇNĆö49¸lŽ$Ф6÷cí˝)J9“ÉLą"SÖá2"Ž1ÓFăh3]řLůŮ p4™7¸.lVhëmŹč+])Ź›ZÔ`DcńS ›S<áxWoK—ńˇŢâiž#DÓ<:D\al-5ۂţʴŽč5Hł¸…Ú‹i5zE‡>& »Scŕ¤0 .Č ˝9;•PťíőH“+A7Ć2Îń–ËŚlě34»™‰žĎ*2«$OBf5çÁCę¤Ě¬Ó´T™ő…aŕZŞ1™“±FOđ‚'>sĆśĚđĚ"—ťsF)śpJJgÎL@ˇ·ąJ٦Đ\F›˘ĄE‘ą€űŕNgĚФu‘yĄČG™ńá¸đ–śU1óŢ.đÁAŐ…Ôr¤ńBEI^g…Áڵ6YáH©¦ĚI!RDrŹ2p>Š˘ÇIÁ[. |ŽB÷ ˝)<"P§0N0ŽŤŃËPfĐŽb:¨Çđś8 Ź>:§y†ňĄŽęB©‘6&‹BđÓ‡rFYđ$dŃŢŠY,Uü’2đ —ĆŞ ΄ˇ-ÔO©Tg9íFšˇUĐzjła_¨… ¨¦¦@oŔ°ÖаڎY‡+zЦś/´§Ą‘sĐ;ÚRáG·nŤÄăże&nĎçU=ű§uş~0ť˙1wŞĺaą|!a¤ňĄřQü$vqˇp1{ĺ¤Î^ÄC>x¬É ÉÔ*÷*™nîAłŰŮ­[™ŘĎÄýęq•‰»Ů7“i]ć»{·ýţp\Źóz|0+żÍţýďţIĐÝě…rŹÜËÄÓgϡ»y"ÖĺĐ›l~:›˝Ľ´­Jmť g٦0Űśš¶Ţ6»Ő¬Zî/Ć“23M—Găş.—s(Cşüá}}ż×%ąŠ‘¸WÍë4×{Ô1]K ďAÂm;Ę=č«’±»EŚ]tWŕ#”ˇ˝˘XUEőQşo¨8é ‹GËj˛_B óî˝L<.ß×Y?ńFŔŹĆGĺóš×ĺĽ^AŮ)Ô=ŠqUť.'ĺ*aŞzXNÇwŞ÷Y<Ĺ (Ť—č :bÓ.éĚ O%0“s:úîčÚŁoŹ SΑv]ÝsĘĺd,=@VŔ{®,­Oĺ°ęË•ďhZź|?™ÔŻ+Ţ ©qÉyLř“'Üm°·ĎLK(rŔyO  %'°|bŕŢrB]G \Y.é…>EM½Éb±»űřůé‰1/(š–«Mnů[˘ç2TO€-rŁé˙sźÂŹ<Â1@ŤĽě瓦#nßş•F·'ő´š‹}ńűŢO,ß×őbő˝“ĺxž/wËę Ď«ĺ‘lýk˙×| ‚¦'ĺ·Clőq ©´ćrl´ő©­U:—¨ß¤-—śÁÍuŰŢ7‡Ţbx˝Ś‹blă‡@6âčĎqZ Ž[Z™;pNU2ľ•đ폹ý¤ąLko·g»`6`Őô¤éaÉף„zâćqĆ mg™›ÍšZDD*¸I[ S`ňłI[„ĺą–q»ńËşm Íf`QCł9o#bdě?ÍhĎ‘n躎ŮQPíQ·Ç6Ę mtÚč&´ŃMh8Á,­9¶Ćî1EkŽŞ=ęöhÚŁmŹ~›Ćka®$ŮKÓ8šĺňž‹|ć``Îü˛ŁĆI•[dT_†(oÎÔßE•Ç´jĚ’:ÜgM8#p gô C¸ôĹč± 4ččq‘vńir~ŢßOÔl5ş–E¸Ž‹Ěďt˘ )ňç$$4ŃOG2j“ćÓ”ôÚ¦¶ĐÎh ¤Śú"´hĺóG#–öŚ­áí¸ŕĺ ŽńSëŻÇ«:ŞŰ#báJQOÄ•ýŚô¨tŃ‹ĘŔpT‘ŮĹĺ2r.`Yä"đ®Ň“FňÉxÁČ?·Ű#F+0…‹‹đŽ+`‘ODîsäö7˘ĺÓÉBÓ\ČŔkńlX2×{cÁ$ŕęéĎ»wďň7Őá8%><١ŕÄ·×¦Ď t>!Ś…ăwH %č$‡«“GuĘ÷.ĚÎÖż®Ol€×¤o‡S­P2„mE¶]Z{ĎrýśŃuZSyA‡bÉexĐęÜŐhí¤ľBřşŞ^7”ľµRLe¸ŕżlV®Űx“¬|ŘÖ·m%lz٦.(hËfĂÚWvł¶€늏·5 ÷<â}•+¸ÍMÚ›ń5Î&M13VoŇ´ŕ’ŰnÚ4ČxÖ˛š†ůĎ07®ű^ľ‚Á7cZŮĄM:|6iÍ´‰ozRúŇfŽZµiŹnÓݦ=şM{twżMt›ţh÷‘ôçÓv\řś/• .SqqŘř\ "´3ş­ "«ţµŤ7 Şš×_ą„vHÎ×› ő)„Ű_Olá»»°]ŤéÓą`Ň7dJpą#LCż%Ň]ŻŔăiKłš•`飯ŽfĄŕ–8ębăŐéA[Ť\Ü!&D˛ DzY[…¶E±Y[¨BPvٶ>˘­ŰڏD7k[ ‘×›Ńë íRmÖÖpˇÉoÖV»śÁŮVcČő¨q=ÄĆ—ź řÎ~˛L,Ž^/–GŮ‹žq·|;ť”{÷ďĽäP/“„ă©PżąOĄéšGčüFĄoŹ1úâRČb·Rp§JşV*mçâuę(eŞg§R[Ô§~m»ľ_{­íÇf}G‹ő±!Ś:BĄÜź“¶“2ůüó$SŇý®΋¶O[^Ž^Ŕoă·02§âđĎňbs'űZţ±'©sCȆ*kްPÚ]±™§…vqŻ”GŚpŽŠç6FéšŰů2k ‚âŔ=e2‚$ťšNG/ą8Ťö.ősQfÜhČu&ç­ä2;i¶)MJúĹŹs’Üţgą–ÉM™Žşťôśűß8 · °ku’KW8’B<É’zűUűľ€6:Ęę‚b¬Le¨uŔ2mr . 9Ě\)ÇHMĺîH`ŤG?gkĐ&]±čKŤ‹*¸ šcŇVf8’ÚČmÍH’‰~Ô#®Ű á±Ő:ş¦Á€-Ú'Cë¸é•ç"´‘ű9#îB2€¦ť¸ÔÇń-@á}†]ĆŞ ‰Ë,ÜF ípşs<˛AÖôv•÷HMç€ä%éľ ý8¶°˝U3”č|ʶś[7Îşs#­3î|ÚG}ĆH÷”ş¶oëčîéXóa‰okÇŽĎë>±kOţt÷şbšŕ¶ď—č]çOçŰľÚööq˘Ť:űčâ‘›ÚGÚĽŢĘŢ87°ęÔ×ŕo»ÁÚŘ´ŰšÇF\üë(H"‘k$ôľ|ş8/ĹTśląŮŠľ§˝ ŇZmÚek. žDuOäHFéż=čꢵ­ëŹíř&uM˝keű’¤Ćą’Čí%¸VÖ%¦[)w’?_HX±Ţf]›Z ¸L=©ň-„Ąr),/z Ů:Á3YvżĂż† ,Šy36Ý3śaúŻzQŘ7tpÍ=řŰ Lh2(5\‘…€ŠF@ȸ!H<NŰÚF Ž_Fxľô ůüŽŢ¶ĎŠM?ŻBurŘŕłOĺ’Ŕ”_z€ËĽKA„Ńi®mâĄö @ÓËw~a‘‚öIa„ˇłŃIŐ’ťđRΠE2(Á>¤Ůň™6m˛’i&Ü»žh`Ř,׬ GĐôęź ŮDň&´F“„‘ösÉÔ•…ŃxęŐ tC{§—ö>4Xh0ć8\{xäŚ0{kij’‘ęF’†vîíp–›lŹ}¬·|ńČŢ8oJÇ$ń %K-H°V¨ë…ZŇiŔů’°–A-X+I R™_P ¦>Ö ńţż„x© -¸ăĺęu-®čÁz×Řx0¨ŠápÖü†hsxľiĎąíě6&7Ă_©s°m\ZOěĘUw7Ő#ńŰŽŕMŢnÖ‚‹ľoű»6Zs>-őmΕ4ˇżh~ÓK™,˝P‡f¤Łs=ŃÍÄRpÇŻRŇƟ؞»ôc<ĎÉT«SoRmšBSë΋®gßşů5‰ sžP#×Ý]úY›Ů-Hť­zsµńnąš,§‹şZ6«ŹżŽOpç§wźüđŕ»Ýăń˛.—wďÜ©f‡h0­2Ű´Ľ“Ţ ďđ“ž~ď¦ř5YôiKŐjÂWĂ…S#±;^üXNŹŽkđ© >Ź÷v€Ě#ńS=žM'·çGł2“#±_—'OÚ#ń´í„ZRÁĺÍoĮ؏Ĺs1b"E)^‹×ŐéRLĹLśą¨ÄB,ĹJ¬¦ďE-Nżm(˝7ĹđüH’ď©ëţ—s`˙ÎĂźo˙¶Ć˝ęd<żŚŞe?=Ç9dA°Ŕ_‚`.áŔmq\¸+~÷Äýô†âgń‹x Š_Ĺoâřłý.ţ#žŠg‰SăĂią,WÓUâŮdRNgł±TłjŽß““qbdz–(OÇ«cruŠ˙·ŕď¬ađ‘8Ç-ŽË9xýFüŃň{>ť—`z…ß…XpCŔ¬|]7gË4â˘\r˛^–Ą¨ßUâTĽďÄ{ń—ř[ü].«ˇÜăUä~wďÇűű÷ÖäŢČçbÁsŹD+xř˘äšŕU>ČŕĺPđJő’żL÷)éFĆŤ„źŠqkŤňW‹W˘Ěß©«Ě˙Éťßžď=˙îÁĂýń|ĄäG ß"‡ŘIźBüšZ{6{ Ů󲟽âŐĹ–oüŮě­ CÍo¬ľŃÎüřłŻˇ 'o®2ůĎî=ŰÇäVóęAýńé;›íÉđ™;zL\›˝˝Č^˝5j(üFđO?`BůçéxÖÁŕ‘8Z–cčíşµŇVgĺjŐsęśI.f§+Ře›«ŕ)Nç‡ĺr5©–e2ŻsŚuWaěÓ§ĎwľÓ2lÝ+ŹNgăĺeśśĺSޤňgśđuŤ«ň–úx)KoG‰˘ÄĐń“čIV,Ç“’ŇYI<ý٬űjś77&—Áj'¤©›IęĘĐÚʱÔćd5%CňzĄZ íŕłó:žř%xę®äGźýg÷ţok’˙ś2uL‚ɤÖďâNÓĺśęˇüw”˝‚<čĄŢIüźîšĂśźž€ŃÓŁů'|&ŘN¬Wcâ"Ľ’Küĺ÷_~xň軇ăú @őÎď> stream xÚ­veT]Ű’5îîäŕîîŕî~€Ü=¸C‚ÜIpw'8îî®Á>î}ÝýzĽŻuż{Ś˝ŞjÍšUłÖÚ›š\EťYÜÂÁ (ăvefga(ěÍÜ\ÔMÁ Ěv€w#75µ¤3ĐÔä–2u ´) 9€ŔÎĎĎŹD tpôrYY»č4Ő´é™ţiů+`ćőźž÷ť. +0€ćýĹhçŕh»ľCüŻ7ŞWk ŔdH*«čĘ)Éčd•4˛@0ĐŮÔ âff2(€Ě` =ŔŇÁ`÷ŹŔÜlú«4–w,q€)ŔĹhzßô4:ţĺb8ťíA..ďď ŔĘŮěúŢWlnçfńw»ĄĂß„ťŢ#ěß}ď`*.®.ćÎ GWŔ{V)™đtµ6uý+· čÝ p°|Ź´p0wű«¤ż}ď0ď^WSŘŕ ôtý+—`rq´3őzĎýćč ú›†› lőOLg •©ł…ĐĹĺćűŻîüłNŔ«ŢÔŃŃÎëďÝGý« ĐÎ’‰ťă=§ąë{n+‰őŻA‘[:ŘŮţa·psüOź;ĐůďŃý53ôď$L-Ŕv^  %«’ë{JÝ˙Ne–źČ˙‰˙-˙[äýż‰űŻý·Cü=Ď˙ -ăfg§dj˙>˙¸`ď7Ś @đ×ó˙ĹšÚěĽţ‡č Ôţá˙"çjúŢq°Ő»l,l˙0‚\d@ž@ «ą5ŔŇÔî˝GŰ5Á@g;ř®ĺßm0łss˙‹OĂdn ţ«é<ü»€`‹eţ.Ď߼YőT¤$”%˙ő6ý;Jĺ]uW /Çwb˙Q‡˘Ĺ-ţÂpđř0łór9Ůxß'€ź‹ßďČ÷7ű?׊¦®Î O€ţ{Ńlě—ţĎ?W†˙# 6w°řkNÔ]MÁďŁő_†żÜćnÎÎďŠţ}ÚßKţĎőßCzÍ‘çĚClŇ2Ó]«ńsǤô{»ŮˇCKę4 ó+şŇ"6řż›r|Ů‘gŘęĆłŁíJžĺűQŇ÷äc®Ň´ń2î~f5*AM?ÖŽń9źUX‡ŃăaÓÚÝSU3*~†#™hătF8ż§¤tĎġşsDó7O­ŤÇmǨ‡ŔŞ.8:¦ůzpGŰ?üsp ë¶gçcv<"µ )ľňy’«—‰óMťů‹sĄ@Ö×ĐqróŢ!8–Ç**än*]ńb$Ög†iÂśëQćŤKţł’űD‡ň$5†n‰ŘŤ!ĂLőĂ€mFu Âď…\OĄf¬íźyÉ3î“Dë­LíĂę©?pĂÉö ĹŢKDZجMB[ůÇ:#˝MsQg'ůŰôs¤sR<#»#ZięTĘ">·úäť?Řż*f_p;jO‰"3ŁKe™[<»!Íj,,bň(kŢJ{Ű×±t,Ɔýt.żş6‘Ś˙čëçRi/%ć‘U˙9+Ç6`(KTű-VłŠ(ť9ďî6M<˝)ť;m…ÂÎS<ŕpĘóÇĐ]ř¨1ůéČŐ3 g¸iéLi ązf’ aÔkQĆ­×Ŕ·ŘŠ01[Éńµ%)CÜ Fň’‡üŠJĘXďćŁÓŮ\˛˝€đ×6Ôě‡ůł«B(Ë0ÖóČó°Ňź"#‡Če]”!Ś×ZkĘ(€šŰľ6ż5Hč•,ʤˇJt¸ŰöCżĂžĺ^A†2§Fd)D»¨ÖěăAáĚCJu™ ¨ Fi…ş^řâů3:›ďŕÝka®M”ýqL«Bő/ž%x]Ńď=C­r‹Ä¬2DŮbMĂ0řV‹9’ż÷aQęvŢ ^áč„sŽŔ•Ťz ›~–us4xŢĚG<ŇĂ÷XZHt!°íń‡~‚kĆésÂn'xŢ®Ą}zE¨›˙Ś‹Ć*=lňaş˝”ŚOé ÍAÔ?×KČţüŘL¬Ú ;ýcÇě{DúÖ—ÔϤ«5qiáŁţqťK\cSQ|ýIří»çźŽďď”NGÂAS0Ӓ̧bM‰ěK¤c¦Á˛lý•ă=đqŰOUvÓnő4m#Ě(Ç>ČÄ:’üd_rF|GýČ#'Ű–=áłyćśč{ĽĎsJXKÔµW‹đü…P—•żX^źz'2M[‰É~Ši$Ą”»W5•W»ŻÉľčGwwĚü0Ä“°wfBĄýL/™ěÜ1ź2ý±¦˘Ő¨'*ĺ;"[§öylŞCI˛‹źgů~nĂŃŻÄĘľD€­Ŕî•‚ý©hó”ĚŔŠÔŁ*=0yYÚŕWç!q>×2ő z?â…ťâş&¦¬V:D• ůP?Xĺ]ŠŰ,:4Ĺ2ꋙٌÄR?ˇ>@ Ţ,Ćü8]ćrsK"ĆŚ¬l ˝ą`Éϵm÷ó|ú5¨üŤ ?aŐuŽ[ ®¸=58ÖxĐţż\Isd¶mŤŻi‘nĚĎϡ9ß' }›oë)đ'9…%‰ďY2g¨Óń&X¬<ĂtmzsͬůdKlů×JôvPFßaů(O—RžFŚgŇG¦*9Ç_[‚`iý»†‰ĄyÎ÷Ľ˙€ťđ\SĆPYéý¦śt«‰ \Hµ#Ľžđßd­îô­|ŹP”HĐĎ!JgŹOŇ‘ôcqÄiŃÁßV„!JşŕŁ / =D1µ 73b ~u¸;AwGÇlŠ›•Ť§˙˛z1XľěËÉSř®†Ě’xîMŻ6Ě3üŮmű”ĺ°Â+“¶‘™Up Á7óaĽ®ü—VzÇ׺Ë2çneĚŘŽlúĆźéÇÔۇá\ą#ňAŠź•vFÔŹcě¤#("'Ôľ*7ą+sk·ŇQîBßĚŁ´ &r îkşęŐKcŻçQ¨Űqg“šÇOjŐóŮž’Qo__®›«lrń˘!Ë‹tE)zŤŔeÓkŽÍm_ÇĆħ[(ëKP|Ç^zú!vgć‰ďÄň!ů7…i˙śÂ|ČJ˛ęp|"ŢőÜU¨0vĄ~Ń«S—ČĐď¸^‡„Ôőv1îŻ+Đi[vK­q7T±ł'·†›el â”XżtăĐýHP•c+;”@‘k‹ýÁ=]rb‹ň-¶ĺK‡á˘ń J¬ţŐţTëy˙Düp×ÇÇ.&qÓËŻŮ0á ^j9Ń®d[˝]i9§?o€ÝJk(ňěNťM†Ä-÷ &R{9Dč§ń¸N Rł«čŇ‚ń…Ĺču+ŘĹ“3Í4jŃJ˝šŕ 5üĽĽ¶?éýЦ5Ä…śŹĘHťöPşůý4MŻi™ ÚÖhIűčá.äĺĎÂó źúô1ĂPĂ™†Ő€$$ś¦žY96ă­\Gt?dÔB °4U‡i‚-쒭ϡÂt9ţĽĄ{Áť+e’áV^¶n)oiŞSĄ‹ŘŚŮä]Üj©CúݧĘGŠçÜ}±_ěmAĽŚ 4Ťye?ÔŤ!áŚ^­±ŘťÉ–`±Ľ®I¨Ąžxŕd·zÝž,’…ćňĎĂwŽ»ą#˝ Nć6ł¬UÄDŽĺ)ä·‚§(9`ÝŁ‡k{Ň€˛)NđZÓĄŹRä?·÷7JĐÇ~¶ŻRq–ôň7 ň>šç飅–ÎŤY[Uݰaăöö łßÂĂ™p˛hó»vďb?U@ŐąĽ‰VŞ«łVˇG\!|ÝN䏪?ń‘ĐkĹâ™Ţ+(ľ,7’¤)*ßÄXÉ·Ö á Ę81TÇ.‡¤Xw2¸ÂýÂ}VúţaKV¤A÷”ű±Ŕî2E0zÂîŚRuâŻmtL z…TÂ[.‡‘EL®a3`/E­ă‹UGM-z¶{/Ý8ˇ3-ĘýpŇýä˙‰®ěĎ\•<ŃJ?s¨ˇĚ5ó¦gĎç¸}ŃŻ†˘Ę/ĘâÁçŠbSŢ|áÖ~›|OByĂú|®°źg°uvd`źx˘jz»¦ĐC$„&á§T.ňÔ-EޢĚ!Ľ~Nm]ÇĘîŁő˙ĽH¶ŃE1]é<Oµ‘ŚrdEířD}aDŤú®$±öęaqÄPËşZZE&+áF°PsíJ™ă )i·× =ńţé¦T2w¦í)羏ż†fˇĘ+±dM$ţ#đĺdTšhI6&­·C$Yn|cŕ0”Öp"Eo=g!}hX™źç­iőë9dC"S:ÁhÖzoĽžCx¤Rßî‘AA%´ -|}Şi˝ëaýö÷ŻÔ®˝dľ´áµ0µc߉ŃR“|÷ N”ŃŐ1Eŕ–Ć™˙‘˘e+¨ńĄ›–JHb‰.Ťłýĺ×®Öµ`f×§T‚°AÔŠ «O!&ÇpsB˛§¸bl>YAe}UţZ@ šłaz‘>P˛·ęGë sVůEŐÝ*qÁhUŇ™›š‹ }]„áä j«B˙4^<ńűö»ŁäK}]R¬ťŐ|h›N1ę°~V:5M]lH‘*ąr Z†IiŕšÝT_E‡ŰOĺgŁLVÇR?>2 ĺŢëOŹPwŹŕ.gorf ˇiż1wśčq¦Ź´Hy“šY,ó,žĂú.´€¸źÄ”§±›+×Ůě&iiGúóĺG8łyŤą#ôă®¶~­ |S4NĂA‡ŤjŘ+ˇn¨‘ZĺkŞ˘†.°"Ń´É›łĐűćWĎşJtŹé.ĺrajű}ďŃ-‡¤Yo@ş€’j€’Şş‘ĂĆQýmţĎĽŁj˛A&ű^çÁţĚYÄ,9·ŤÂ[u„6„x=łAÜKłSH=Tř¤ö2ŞŃ=”c=ŞŇKą™nżëuRhRŃĽŔ,zsR˘¬ě₉/ßęéćqč7ǢŰń”şicZ™\â7h—ÖÁ[7ÚĆZtá/ÜRĂŐ'®5éiR‰‹źQwvr.6#JD¨t6Ěłs±J±«Ë¬•¨.ŔisËKĎD«FoË\,¶\Ďá§G<ŻuâYyÚżŃă`-`UUŹ:]tżĄÍx¸Z0µAćŤKÔČ>ęëMž“Y cóµWćE¨Gßb~!)žĚ=9ŰŘsüÁmr쀋׀˙-âÖ{SŇş¨Ť ŕčGÇü13Ű»9ďÇľ–f°ľ#wdßx\űYT‹mضÇţ"Ăă‰Â!ä ěÝSÉk(4Ď^Ü>ppˇ!öę°ŽŰ/걆ű?ʦÄČ-úšGSš¨^»;@#ŚJě~°nđş2ŽŤ¨jh{lŞäŽx଺ůéw š1Jć‰ZŮ4jMÉâ'&“µŹĐü[]H‡¨(îňËpY™QJś§1'—§™ Äď‡Ĺ×y°J–%PQ„ÁGTö­2`&oÚki×—ĚçôĐb8,ćĘ€Ç"Äż¤‘Á˝Ë|6ć0âäńFő&ŰűpxÜd•]e~dQ"ĆŐáSףpógز®‘َŕ[Ä †Ň?;őÓJaÝ?šź–DŃ Vč˝öw Ŕ]›źH'[Ę}rĐ”ědl»oą„˝.Śľ1“Áć7Ü«śIúÝ}Dî%K‡&4*š„Š¬Ěâőë ŕe[˘‰Ľ(yŮ˙­ű»<Íč‹(‘z)l iO[·AFöeű ˙~R/»)R‹ó‹ú!vPś*ůźÎńč繀H2äJ>Ď$Dx«jVońî% )O‡é[~śd°ş˛oăÇ÷ČLѢűáËteÉv÷7ś¬­Ő±aúÔšąŇęŤbÚšźŇ´ëzń•Ŕ8"©žö§-Řŕ€ąDCqˇwA˝›ëv±÷”a&›l—6ĎQţO"3`\ëęÎś˛Ü'^Ď!˝g\Ťľqŕńî‰bžČ' ŽŘÉJ©ġb„3ŮP‘­¤«¶yx÷›ë ďÄSŐóq©ů…ś–Uť{NYýŹčě'éaĄ•QlńY ş,°T8ç;Üyf˛*ˇ˛Î‹U-‹â§ü­-Ëü!NE-řŹ˝ĺ„÷n‡ţúËČś^2XIŮBă %†lçgňѸ"ŘŢQ#¶&ăg‚¬µ#^™g]bdĚ.ZK ŘSˇĺß-Qvă*‘jż }®Yń|ApMT^ ľ,6¤#Ă<†Ô-qTmú‡I„´€Žý0¸č•>-y鱟.Fsf®·3¶óTŽxĺ5]&”ăŞsb5f4-ĹÔ» wÔ>¶˛, ĆÂjnŔ˘ş6?k™Ř·/6™ËŘv:^î§=-îŰ6r*†j·ßOČ–ĂniŰ"Q¨đ1ěÔH)Ń,â븄?ąĚ‹µ8Ĺ[z ę)b4żťđ8cŐ!hč"ŃtzÄĹ˙‡I‰Öc™~yUé ¸ÇĄ„úM”Y oˇMńŰ—»–ábąęĺi© ,žš›–ŁÖăÍ“W.šęáYůnP[*8đ˛î~űFu–§ë­@ ÓuDeˇ8Ź%žŠTS‘~´ÍĂHÄ8_YQTöä37¬F 6y˛ľŮ‰©ućL»ąh`šÂ–W®łä˘{1 É:Ąz­!ó”Ę*ăŞZ¶ňl˙ —î ň¬ćůWÎÇß»V ‹;L‰Q«¬® U9Đ­`i+Š á^KÁ¸R9VÎŽ_?ҰFºǺ† 1ĺ>„ââĹ—r N°6…í•\}ýMĄˇ“ąF_˙Ëňą2Ë<0BÝK¨’÷'ßů‚Á2ŁŇÉehű•±Đň7»HbĎL2\¤‘«ŃľHä’cíAM“đyu ‡éíź^÷PĄAUĹ#)m©ţ ,Iiżó¬·Ţj“ 8 ă]'1<Ů1¶I„öMš)8gúá6ŢHÍĎ@źěx¦”»“f¸đ`ş$Ç\©ő0de&· ŻK–›‰ţˇEł*\(ض&Îva–dń/ ‰6@y‘.7ů0Óת›Ös¶9@ę¨gŰ&ťjYŘ[¤Óo\'ńE˛Á€7@>ĽöPܰĂţ¤DŚ7¸G9¬ …˝úËńš.¶8ÚP%_‰ţ'Ëbcﱫ‚ˇ;€X[7…ŽFS»„oÚ “h/Gv˘#š\Xˇ˘Ĺh}ĉˇ‡ˇµ`ŤdŔĘoŽ·˝¸Ůí4ÄkXł_hé¬fJĎ;ěŃ€uůE”ňűÜ©d]YŚű6s’oÎc&;6oŰă»čî_ÎuŮ–b4Vű|_;G ÔzłßgíáeąĘH$˘\Ëß°[ľŤŔ‘Éaneö "vé.š_tjE§qÄÄ;¦™¸˘®öpÄ~„PŃŽ Č(€§ű—ŞdĐ7…ˇô¸üO‚H/Ĺ^zió2ľĄůľ_™Ě6@±ą9%—FQĆkţÔxŔ&v»i,ŁúfX…^n;ZŹ’P©MÄŠQRî Ąš>=-ý6ť»‚vŐ}KŢŔ­?]¤źpLöćK ś'íŚ(K6Kł aČ …bgÍIĺ.éüÇÖřh“ş:ĺ\ĆÄďá) ŕzćĺ¸2< ž&(ľďX$ĹmŁî<9‡ IńĂ’ăŹőÔŻh-QaAWŰC.ś22:î-”NĽ@C"dNćâ yí0épĆbRkšĹę~Jd„uĹ44gĹMš?*çD˙ś?ĄĹúvÚÝ ę}mf¸°z¶7çşM秔džK´UV–ˇ)€“-ĚřŢź^ćű–p]Ö…«.™}Ç´P›+ÇeŹ™ľI5ůs“ů„jŐĄR”Ć‘–łP©ˇŽ4ˇiéWŘľ•¤Ť«~\ëJ Ť,E}{Ôw°ĄüůĆ@öLžě“*…·^użĆ÷N“ýüŰĽĚK!­Ĺ©wˇ€×_¦N×Ç©T^żyďUâĺgbA”+ăëŹĘm˘ŔâËd–zD»‰Ť@O§űŰKç8.ă â0î źĂ.ľ´Řˇ·y͕૩bl'Gµň˝ p¦b‚Y'ÉSEO‰ë)_uDłIŘiÝÖoľunh’ıeD2h‰iB…†÷tŹąëÉC°/_ysěÍá rj|Ňá[ós TĽ•üÁńČyßAHXxDó'Ö„qpÚŃ%Z « )Ăn$"ČŐ'tĐíĆBdĄéxF;¨§Ć`÷'řÎV=[ű“ÔîvőÚž±"Ő7ŠÝXî¬C(×P_ëĺŘ ŢC9—OiĐz$ÉMBKĹpëüČ#ń٤ Ů×’ˇÝŁ:>ö@ldňŮppŇČ%ô9rú.D«YÖ]ŠTbřmüá„*É W}™ďVl8c2ŽÖA»?Ŕ“<4ł&ńwš‘i[«áąýüľş<“÷i…„?lBŽ(8?5˝“˙pš…&鮸ú¤¨—›3Íz¸}¸l_#ě!ýű÷Mhł2Ô[­Ú:â)¦ó:HńiîŃ}ŞA¤^i%q±4¬‹T'ÖeňHÖZťi/2Ľmj^_ęywô/ËŘužçkˇqëÖG°Hţ{¤Zꀉá4XÖkZOđZ~­|KÚËlcFó©şöµürĽh‡C8dÖ1‰ŕT]Ý:-- 1“ůëşăá÷ž'¨µŕ—‚â,YX›Č  NŤś¦™8Š'jqs¸ը°ÄëW‘çz ”NĎFަ5Ťř/I”'lşMĹ"w¶őSB걄đˇ:]pĹpĂŹW"•ŰŐk–•^‡ůr¨±ŃÁşudYľî±Éj×ËH7Rń͇Ý\śĽ~ íHĂľ{¤ěŰ ö´ŹÂC‡[Ťń«ŕľZvôd%ľ«“áÓµ?-ĆĺNBď”č*ĐŮçiF—FÚK’…VÇ ÉĽfĂXí#AbsÓΕ±4®é]fřâÜpEµ›&Đ fˇĂ‘í l=Í;‡űępFĐ»­h!B4›=HŤĚ˛ÇňŠ (üMh5s7´×šs'FPŤ:N ćł%łéí8—BĹaí.M(÷ÉŮiŮp˙ébí´Ö“_5šD$çYÓ‰áie쀞KŔ˝ö;ą:[´–Ç(Îwâ% âćľłĐBńn\möţÚb…m%l.Ć%\eÇu’€N _ę !Áőě8ąťX*¸¤§LźE3“2I_ě ®:”]ÍŹuÎôFšib¦hČ sĐťmYt,1ذĄc±Z_ࡑ|Ů’9pßVëo×wLÄŐHŕ±7 xaÍŹ­>“Lô’ÜJĆcŮî%±/aĆ«‰ÔÇx±`4ÜФd|QĐPorů7Â{67ĚSł3Îű #ęőőe2 ‹úĘJé__yR–(L»ĂëöŻÓń ÷§"S$ą˙Č›óŽUĽcÚ-Ţhk $ËM)1éRę‰őaý1eú’Ú-ĄÇf`-ëŇă ÷c Î;Ăm:ázĐeřŐ_! «9´[Ů‹ cH—JQ3řDfku çŰV-ÍěźDë†]"’Ć˝ô©Gře­·yÚü¨jäPĂp7ż¤ł¤ZŕzMm_sJkkA _AúťŇgО,3ź÷Míć,Ł×N•H{űG,ĘIęľţBŽKeÜ'a%Á÷P2×ńd şË«—ĂËž#*á04*Ć=jĹesu ÝDŁzťí ‡Án†XJ zŽ5ě!ź|¤SΰS$IĄD¬ţ™7đ§RđIQh ç˝ĹüÇąŰqw°‰zęăů­e]Č•áńdĆ›y-˝7`]@´»íqđx‹ŐIÎÄ›(m…P/{-ňü±÷VÜĄ-°¨őŁ*VŢź«ŠŹßěŹ43ł‡TaD§ŠžăGúSX/+Ś Ą§ÚćŮń Č u‡îŁŚ ĄHĆÍ/ĂU‹)b’]ąĐĘÖÉż\ÚĹAł?ϰŞ×űl«˛H}y9Ľm‰ ̱LYiî^نlľ>µÚ-UlúĆ\żcŻ~xłý>¨P}vuÎŕÍEß´­_߉s.óe˝‘u–Ç ?ÔŁüru·Šöäc+:xt“u„ÉCĂaTC"ΕKżłAš ÉéKXú.ěěŘM|ŻAu_IŐ Ľ.‡KÇl¶+şföʝǑL«+[K0^ÄťqÝ \§B>o:ˇňŢľXćľĚh1«ýňNZŽ*rĄ™Ô°§–ŠV'"Vý¸?ÔÇ—»¨ęµ‹˘\ÓĘÉ=-uŢ=ŘŤZó“~WC¶{ ˛‡šTÔn’I vزyo܇![Ĺ›k ­X_#nbQ-‡ň“É<µ˛óżEFŃ”» V[§Ű·P®ˇ†ŽhĆ>z0¤Îrđن" ş•DóAﬠȋK:ö>ôń·^&iľ<ô{‰ÉŚŁßő1>'E^ŁXrŔŢo†ÍÁŰůĂHçš•K1źf ľ˘Ö»°ňîX_=F}]kCHmń#Ż8_]™Í۸“ůͱľśR’k˝›·\?Ě‹wL­éĄRŃaaňÂ@ĹýcVŞ€Ý ó3é­€îĚůŤ·E9ŐÜDÉń,3ߏرZĽŚ üIßÎ’ĂĎI7őYťóÇĐß’LZŻeovű¤^ňÓü‘$khV-ôąĎ…QLçđC z’­«Őŕ€U_˘J®ŢnÍbŮÔ§YN–ĆaęŁ>l*÷D ČxÍ2ůQ˛Ícá«iOÜĺôÂtěÁ"wŮ ÁĹ`Ş\%‰Ň [ń_ w˱;Ů’ŠiâcVš ߪ5úŞJVŞŰ~GtAÝĂśe5HćĂsqĺhXŃÂ]Ńe´“Y®QĎź„L‰»Šé±˘Kó’Sčq5^fč5}¸Ĺb7尦̋7¤‹ü6µ<3ş|A:%›«®¸Í†°;:K„şźÍÍń@âń›•» ĂăP‡Â&”=͸ô%“5ż*.R;¤e^Šj–1ŽíJ<’ˇ[Cî{‚úlű#ýŞő›H¬•KĎrĽ>ęčÓ7\â+VŢj{AŠĂŃš ›ë‰„Ŕ}٤–kę9ÔÖŠý*:l«ox9†zR‚i "Äëa”#+,GFŮf{Ł$ş<=J):Ý- ß„:9°,őün~'—ž,ˇŮúťŞ˛âŤ)ľÚüËćë<`‹ku&j –<\EęÍW(^¬´˘=zŰ ëĹLnPlŰÔ×Nµ4XSĚűF[ĎĄo»{ĺjjÓ–T˙[÷26kł¦Rw±QCo3 gíŐˇdó¬§Yxš‚Ľš QéWuI»UôÂ9HŐÇĹź†huwű ¶â†bŮ(fěÎŻ÷ö‘ŕ"ÚÔîşóá üuKn‰|oÜó>Üë§ź«~ń®Í"1­DB-‘7D‡]üÇžK”—^Ăiن¨iĂÚýg\Kl籍OQp7–V»#y›Qć §q§«b†·ĺ…›ŮŮńβ.âŇ :»d„úS<üiÓó”ěT.k,ťđ©GfpŞOÖăŽ'eŤLńNĹ`MŇ››zŰ!ĐČć~BزŮkÝRBĎôßzŤ8Y PëÂĽń¬Ąíŕ(~Žíi|ÜĐ‘Q?@ }óÍ]¸Uß÷ŁwëÓ%ş„Kšť¬Pó<ݱ,´†ĎΛµźÜ‹üžňŚ~Ůř§ˇ97*~ť/<ŻąÖ|Xü]/Rŕg”`ő;F:dˇĺĂd·Ç$Ď×6cWěőH±?sn›18őą¸±Iđě$.6$ů [&qž}–ꛤ¯éé^U˛-9BŇßÍř †ű…ZN Ż*VqÂuáťPSżŮ!KżK¶Z7-–#\öáĺöĺžđIµâ WL(Q˛Bٵ«µ°Ł ?ßÇí0GK-XEuQ_ѧ_uV6áső^D‚môđܤĆäPël§ ÉX•â&© |…ŐL§KÜá˘ď/÷튕)šč( ;I{kCßìg˘6gTT„0|á3±Ç÷ÎEiΖ’VżÖČ&ĚcťsńąµŐ¤°ěú`¨¸¤ÉVZĂ*ŃĎŮaß6çŻq‰$ńđŘŚ®Í[u¦Z8U›ü‡Q=aeQ^R )…l»ĘWŠĚV¸˝&ž¸âŃVb3nfzřžP3f®Ĺ6ˇ1 úüIt›óh2!µ] úŁúHLŁ`Á˝}ýéűćt şňW]ĚPÇ ¶÷9éĎ€0C*᪼!h ŔĎ•)ä,?•Čň{8§s57Lu9`Đ"ó踜ňm¤ş˛5‡{Ű;9^ż,-ĄÍ=[Ą rK9)]/×%\»f†1)öν1=ΑeiÇ#_Čř”.ëýęŁEp ˝s™/•ŹČ]9­žÚíŰljÂż…yłť Q… Ęíů:[°Ů&{ßňĄKdHőĄ<Ůâ9ÁíV«‰RSŮ®~ K¸šś»Ş;7_@µÎć34&Ö¸ăÔŢA׿ ü1ýE8`}…–YäT}EŁW@ËWÔpĐî¸2˘a5ßľ}Ź&SÓGv»Ľ MÂëSI„ĂŇq Ô(GâµÄRa]şŮ>ä–bE‘X°Ýň=Ʀoe7ˇ~¸Ö~¤µ":=’&ěTd]äÔˇw‹¤s!¸J e ŹNđťă_ęDÍh…áŁŃď©ĎXÉ<ľ-‡{őęiGßĐ\n`nŢ´ČéýţGVäĺĄÍ,Đ<řš‚šÜBŕŐěöRű`Ś˙¬Rzń^Š&UŰ-[Ó4ˇŃ# ôT`†ůřW»S{ĚÇëŁ “Źyz۶+Ě˝ąNsW–3źrUCď“´ó§żŘčA Đ’•ăa>7C9ŞÓŰ‘C@d•Šś÷ňJV2^Żd’áőuÁ×kz ŕÜóIéŠćG‹’ŞĂÎ8hÉ ®R×.vD *ZV'>ă÷G§ż®XŠ«ĚŮ]XüZq™ŐÇ%†¬-ţ˘*ś ]z×Ć&5Ä‚'¶dPľW)%GĎ|ö«=Ń}eq”ŠóJůN®Ú‡zĹăyŹUŞ*,óÖr Ş)ŃĽtöi{OZ±ÎÎ÷ĐcDEµŢös9᫼0‰{; :?oi҇®!‘M°†äĽEę9’™mqĎ2ygG`z€ČqŹë‹ăA“>jŰ2y&-F÷îí‡6KÜÂĆž"ËĚbődűńŠ0Ó Ę”?uş;–¬:§|Lő tü´ÂŹJ^ öPŘ/ŘÉAZ=ŚęgEƤ ÚΕŐD•śOíjîÉÚláĘL¨ŃĎŁęť™E =Ţ,|¬ĆÓýÂňS_S`ĆÚWa°Ďäs> ›O¤ÓIńĐqS|ďă´`Ücó¨˙<ŮëFŠ‹š±ČşB%zůâ ż6đ±b˨ű¶l BKÖ !§8€GŹ*A„ł«źZ ůęç v`°.QřůL°Ő´`‹€cŢ4T—# âţ°h }cC)HUžżĎęĚPÄbĄ\űĚęî˙˙ă>b7 endstream endobj 266 0 obj << /Length1 1625 /Length2 7801 /Length3 0 /Length 8624 /Filter /FlateDecode >> stream xÚ­weX”m·6R*)Ý0HwJJwÝ1 Ś 3Ŕ ÝH*]Ň-ÝR"!ÝHIŠ„€4"}ľç}÷ń|ű×ŢďŹű>îkťkť+Żu7 #PźGÎa QFŔQ<Ľüm¨ł­;R×ä‘GŔěÔP ŕx‚Ă¢ŕˇ ¸"‘CěŠ0@P ..ŽĂP@¸x»AQvC=c..îK~«l˝˙Fî,‘P8€őîĂC¸8Cŕ¨;Š˙µˇ>@9BöP  4UÓV°«hT pŰ]@w[ Đ„‚!p$„`ŹpŔţ:Ŕ¸ôwjHŢ;.9$@ş@ŔĐ;3âňâ¸@ÜśˇHäÝ7Š8¸ŕ¨» ( s·űŔťÜń' 7Äť†óvGD QH°Ô¸ó TTţ+N”#őŰ7zöwšv°űď”ţ`w4w( …#(ę·/[ŔŠtĽď|ß‘ą¸A˙„ᎄÂţ7Ŕ ârłAČ;š;îßŐůwž€˙–=ČĹćýÇńGë_1@QHĚžG@đÎ'uçŰ Çáű=,jp{@€˙/ąť»ËßÄíOŘĎ Ç] ;ć °Řăđi#Pw.ě˙».óţçšühń¤Á˙‘öţßšűĎý·Kü˝Ď˙¤Vv‡Á´AÎwđ×’Üm$@đ{Ď~/(ř˙39CaŢ˙Ń?Ť!ú›ëźŘ_Ôrp‡»Žđňň˙%†"•ˇ^; vŘ`wĹú#7„ŰAÜ`P8䮩ęyg$ đĚŔ v‚˙®ľř·űgěw}ú9ꮑ1ĐŘ”ëZ­4w#€2đvţ_hĆZ»~óČË#Ľľ<˘˘!~q€€ż(@ü‰˙˙ŕó‘ŔżĎZ ”Ô `ÎĎËĎ/¸{˙ýüűdů%8a÷{hôQ ¸ÝÝśýK𻻹ݵ÷ĎŐżKűď󟉇@Ľ `ś…YX2ôYZf:Ş–"·TŃĽű˝FKɢ‚ jDg`ZäŞx…ÍuMoøÄÍ[.ż6Ô97ß“ĂŘ:S!‡ů´ţL]DˬďDą6Cř¬JđÓ÷ŚŁ}Źf4W0ÍDřŤ6×Fuő¬ŠŻ±éĆß ą=8:çbň("e>s!żŞŹ#k{Ô€F\[¸»Çš´}~ĆÖ;4Đß×yŚŐµAĂ•÷ED˛ËŚň¶q;}ţĺÉS-‘ť6ĆîÄćýYĂŚűžsSŽF–ÎńĐ2MJhĺ¸i1`Fá+őŽşŕ8]ťĄ{IShűwĂŕ‹E“§ľ<1žőČ@âĂř¶Žł]yĺó&OľĘ- CsÉČ1Ć`ŧLÉZGěŽ_Á­ŃLŇ­ŮČ5Řź^ÇO[´¨l)GgR´/5~A+śŔŇ7’3<˙˛•KA=)Ý‚üNĆKĎKc!8źĹn}úp¤­éţ©žwÖ‡ŠŤíĹpá7ňRîfбÝuŇ–CŞŁĺ‘ {Ď6´ËD¤ďµ­4_Ő€P›7Á9kŮGph˘táÍźóT¶«f´Ă_€@—$O¦–#łŞbCC~J.äđ÷4’n笎1Ń(N‡ž‘’^ô$S]Mĺúð«\Ş{ôŹö3“o6x˝qN&Ŕ÷[Ú|lzIÔ7“•bXŹż5E1Â{5ě}ŞýŮŮŻ+”žµČ˘G¸GŇM®še‘<ö13ú„¬ËÓNë{,˛h­°Ëu_d“ĺ¨Tó2~-«Ň*荦]Ö"źé Öó×]bwdŁl ˛)||‘W¦4XöoaÉIÁRaĺ4çô4ËJ‘ë!TŹů&ŰU&"*ÇOř]yjçE0L ľłK',uWšă!#}°~BňşŹů~Ş0ItZHĐř żŰ ^MQClmąŮfśčňřČ—ˇ´ţC>Ű“Ýö,É÷NBěG\N'Ů ‚®är÷†cŰ'?čöĎŐĐŻžeŐĆ4÷eG \»yśHůë±”ôĆÂ"Eöüu-Ë.A}M”Xłň%Ú§ŞŞ’č˝&şěRI Hz6oć­]˘—eśĚp^»©Elsw‚4“‹LŘŤZ‹Z#ęü¤ÇŢ”Z˘™$‚Lć0^·ÝŚAdĚůôźpßÇĘw{éşô[®Í‚>†…ňĄ/á^‹Ë*nđ¦3 ៼ë“=lP’‹ďş>™(éꎅ‡HŔ¦Nź”ëŔ‰Y_‹fqäa1Ńa4ŇIZ-D;Ł ÓŹHGŘ#<۶Ű:xb‹Â>¶1/uNGV[_ďL¨54h{5š˛gč6±F\ľč \°Fp|ŔlŇă›[ [lÎŁ•k:qŠ­fěÂ0ýL[ŠOÍ…Čô-ŮÍ7WČ‹iK×MgׇÍRkw%éH„jŮŻ”ߪX¨á’mŽĐĚűŘă&jő¶€)‰ ÇÄé ‹`J2…Ŕ¬ěTŤ™RSí¨ĆF6OĆŽĎrS›TúéK˛>ç0i&ˇěĂ|ߨ`ę ţ0‹äë÷ÜÝő´ŘĎ«KcjÜÄ 05h ¶ÂŃ^Ěş±–UĽSŁ•“ţşş™»[)Q¨šřÂ|I\·‰$ő¤ U!`äč| SŠDj’żéŻőz©`&eV}Ă«ď§&×\Ë, ş&‰‹Ţ©bXŕNI‡śRë#OfĎ÷¦+DÉpĂ*OYąHüskôă"ĹsI÷ŻdßQĆ6 8ű´_cvëK® ŤťtKä°s)ç %o§(ä6ť×’ëÔ`TŽe—<—`”É}°Ňť¨?°u {É`tż§¨),ĺMó»ŕécU6§ť(fwĽç _u—‚‘2ľ“1±<9UßÁĚ[a0"T\ĂÄWťˇ ˘ú&łĂcšC¨ó Ą…¸Űm˝»`”‹”ăŔC%őźú‰Ç Ănýj0Vćłó ‹ů°ľUÁŰ]?!ß ŇŐŻbY?lpJ1ś”-Oˇe©@Ëľ]ó~%dqá&NZŤ ‰Ňoî©îŇ'>DđB¤ö›…wQ˛_p ™ÂNnë55ęÓL8ÎË)ú+şŘŁćÖ˘u{ŁE5ĘPg+Úx/·iDzŁ\‚Hq ˘•÷?&.\4Ś“öGŤ^ż•eĂł©­âÚNx„5Ë’J´gmrßě…¶†Yc  tN›×›ýŚý¦łPÄŠM—Ś–k¤8´šĄ RqßhxőJł’(‹®x˘<]–ť'ŢďűĐWŐ¨ô†žßřŔÉLŇî1éŘ´n<dµtQ&şôÁąF=DAš$…»J^bý4#ŢĚŕSľB˘n­…Ҹ*&ěćMŐ\ĂůAÜÍ~úˇg9„đ2š˝?ĄđŽZa©ąDłÖ#7ÄjőbeéĄfÉ6ô+Ní})Xâ)ŹO¨ŕ°ä€•f^×§w°Ź_»Do#˝řçÚ3nSKJVDj4a‹p î÷1ÄҰĩ|˝a«ěâYŽ óöŇ6ţ˘÷g"SŔýMxn—ă®ÉîîëÄÓôGoyO¸¸Î9 /˝Ečź˝¤\Ą–˛é<‰ęxŐ “Ąč2TˇĐÂÂT0EŢđa$ă‘®Ź5‰śĆ˘Î™—îí8\ ĹKú/ŠĽš4mŠń^×Ó!Q)Ű1)un TÉŽi‹ÉiöžĎî Ä9»=c'Ň!4v ̶Ő(őÍYĽéRŃ´Č­P˙óř+÷<ˇţ8L¨ĽSŰ€y®w@ŁH'kńf2\ ´ çŁîŮ#ýjŐŞ¨‰9=ý•Ď·ăŁÓă_š€–/ßą×ß‹kí‚ĚĎŹ\óĐ=ŽŠ#}.^íŘ*5mř’|Gkv¤‡‹Ž\P$ćaµc4o8~ĺÍ2?uí“9Í;"Á[laŢŔ˛Ť˝W˝Ö>F¨/éQŹwjKäŮ­ŚîčµßS·JuČč0]ÝAg§›*ޤ\O5™Ďícú^őů^<÷ô™¬˝ý8ŘĄ)Ü޵é<ŔňŠLÂdýŢż¨ ]L´7şä Yő8x/(‡1DŮô™ň¬1NćÜ´ťŽÝ粗¬ 5đę ŰWÇź™Ľ¬îSőźZż“tBnă‡Y[už˝nŰWUŻ:hĺThÁ!°•‘Ă{Ű–j¦Ťë†ŚUÚÇřNĐMËmZĐí÷"ŠěF<<đ svťvIéÓ“9Ćă2f—ÎąŤę€şFŤöŻ‘ĽVäµs{‹®Ż‹+łŚHŰ ÜC<ÇűuŇNx#5G?ďE3çˇE^8}u‹zÉ]đIJązŕĘ­*ÚhˇŐtŽUŰÁ&«Oją±ű9® `¤ąpŠŽP÷ŕäQ!¤4y4şĆŔk&yôšĐ ­IĹÚ‰´÷ýg®é*çžt^KęCČş< ďPjbJ6Ł14Fš ř&‚Â<†đŃĘym˘ă?ĽJQĽ‰nO|Ö˘eVsôDo㞤š†ĺ–;ÄZłĽO‡!IjfĚÍôÉß7ăZş­ć?XKÓđEěe&uÖ­ŤÔku[ĹÎ<ˇ—3?5GfLÓ–ęů‡™Tζ˘ĄőďŐUq?Č{şü˝?ę Q›ő*ć‚G‡S¶¨÷lQڬűćië×6]Ł››§“Ű7iÁ‚ÝŕBrRú‰ďfІÝßě4š.aľ– ¦1ŹěŽR§ź Ý7˛śvîđŕÔÖ"ĹŐĄŃüv ŢmgČÓD1§ˇ˛†4”ńdnÜ%ż±XńoŢřŕY°´GFMŐŽ¶ľ»eŁL·ĐÚ—Ö˝”/öů˘·¶âMťH‚Lg6(Łx´MjžgëŮłg‘¶#ô®ÉsžüŨÜÎĘÂ’'÷¨ňŚý :ŰHKpvŤ¨«ŰŽŤőé=VŃĂĂ ˘Ź‰§”:-j…Ďb(,ż’`ŮŁi•ÝUdšy3©M_R3 Q?‰ĺľţf¸—íÔ'DŔOdQś§ŕ'n:őąď3…¶výńÉp`FĄcĄfäŔ™ë¦uC{XŮq26 ˛×QIYńąYx@Ž>rng…ę‰ţ?íâWDÍ“ë2±ËG٨ć_N#©±“Ę÷Ç÷+Ć;š čX†jŇů¶G ?ŚmYŤb°6Zű }ń…cą §“̡«Ň¤CcS»a=‰yܬ"¤Őnb_w~ĄĘ÷WŢÖw;ZŰÉgdÁ¸/ňÜV*LyUL+‡ůĘÔźźě^/Ő~nTä¶ńp¬–ëv9ĂhżÍěg°đĘcxý[;6ož'‡ l«ˇ=äO$Ęp\Q8ŢoˇŇ«Íz—iî82, ˝ťZ' č“kłŕ ,oî$ €Ě·DłKěIŔ3qCQ1×ÜaćčŠ#íť-cÎ"Ă-Ę~&ç]ĹÎI„ęđ&=!…Ťă˝HqÁ’}˝ÁUĎhĚć»ä»Ĺö®ÎĄë>-z¦\6Yő*r[C!}¦ź'¬AČŕ¶!â×Ţ›ă>ňýW«Oľçg,n;ÂVż„‡o4Ż@C7†éä-ó±‡óyrá›UU_%ĽĐ kVó$Éo©Týw¬#¸V#ońÖjĂüÜ‚l¬–xnŁtâË}ĘbúG€złĹđ*9…«x·îJ±glú$ /m"'á…VŐ‡ďľK2śĂŰyZ5Ś^e–ĐĘ#Ńą©hú.ŽłĘĐť-Řřꊼͫ–=káCĚ<ý ÷Ôí`ÜrĄmŘ3Zł&ó¬ě”J´iX?:|ú‚4Žő?¦sđT~fŹ­ă°X4˙đ3fwssȧ• 'Á•ŹÝ$Łň"|2Ř\ţ‰±wźŃ°ęĽÓ9łQôŮš;Ô‹$vˇáHńóľ°!f\ŻnŰ’ę'9őM 33ťź»ąŔîş©ˇ^ćHŚLű]-îšbÓ‹0„ů÷Ăőx…j˘¤{ůžčŮEîěßď·\Ýwˇ7`ďë8ď˛0* _/Ýud›Ü¦¶Ü±™čÔ Ć÷L獠í—f RŮv©9ÉÔtýµWzX^4zŃĺ&yßç´íŹ$¨WSîýD?¸­ÎݍXíçh^4ë€8ż6˘ |ziçPřmÍ‚-Ę[çŁč\eËätuˇŇŕfV|«[PŽ]ôí+yädô±ť¶m»Řő φö148˝4ĄôúÖţ­őŕ3ľµ/ašŘĽdhlp‚{/Ő®Č3Ac’}±´™ÖlއPŞoL$ÚMhDZ‡Á ˝ĘőÔCۦëä*ľřÇ`ž•®”Q–¦â{aTI,ÝvÔ¶ČÖ˙ęvš˘HP¸g˙"LÜ‚ý°ŔťYő3·–ö……S_žC\“NÉ[˘€¨˘%”Ě.­ŕţ+I~-LŃ˝ĺ«,ý@"7\!“ńĹ2WĚ„đ%[ä“\Y,Q“Ö. .٨´ÜsFÚâŇö`%sľůV‘öîtäZ6 ¬Î{gĆâQ˘iiŢ(g]Žâ^©źŃv]Ż×dĎóĐË6ĂRyűŃŞ”Ľ^ ńlŮ‘˝ Ý©®bĹÖJ—‚1dţŇ×Vđ˘u-QsůĄÉf|+چSëŕKƵîÓ©Áý …µźk&,?|µZXqpTŽ8ľą7łbşÎ}IJ~0(Ü[ 1–(Ă—ş)ÎđŃ ¨Ňuş ŽEb¶ŘNFU Xü܉ĄÓSe®V3)řVp¨Őô_Ň?B ť\ĘŘ艄 _ Š’Í Č÷R'|=˘űt>Sţn;ß§žz¸ňQ%Ż­(qa3fÄŞëÄXYŰŽ+Ű[.OëŻÍ*«ةe‘cfűü•zě„Ë °ćá©®ěóTóČ=[ÝĽ­ŕş…„°P¨w1YmŃe\G iĆ—Ă…Š€n~,cŞvĹęÚ¬śŽLŇáÝ<őťÜę[$ĺž§/ˇđą˛ďĄŁwĘج+ÉżO;šr¬óHŃ(?ŠÖZb}čŞ"m‹‘ĺa°‡X¨ąĆ߀ßéÔ°Q†ŐMXŠIOń¶Ć:˘{™ÚÎ’őäP«ĎM˘y$Óć–GďIJéyk?čUz\şmŞšµp»Dů@YôíŁç¬´ş;* µ`ó,x=‡ľ´auÖ[]BJ‡Ž~q‹GĎ%ŘúK•Ż$üqtĎOS0él™Ű'°µÜ<öÔŻvÉ›Xe6 T)˘±ˇů}ĄPąmśjR7ťż9°‡vťçq¦Ž^ă]i;Ś$´ć|óĺă粧Ĺőă/µ¨|Ç9v´ŕ•oRtŰLŁ6úĂ]LŚŠ;ß塯Ţg•8ĚŚXMÔěŃ´©E«S×Ůľś*×Ř ń2[UáMţűÇśýqXÝâř2í÷­dę_ 'ZV¸!®®I2ř?1•(ž[”ăwK’ßµ×cvĎŢľb=8°číúAG±ÓNžčŮ ý*3MűńޤtÉgáíEkHgpo`¶˝´ş:¶ăŇ3«Î˛Ű© Ži\–ŕú›Ł#űČh”©łčŤÇX2é†Uâ€ă@[v?u ¤çÝQ,g“"yůkîyŘ(`RhčSěz›Ë ]ˇ QÚéáĂĽŕŔţ^‘=Ű€EŹ_Óö8ŇLҤŃQďI—ó‚ $|=”ńÚäú‚'8uÁáLË+[7ń@đFĂhN}:ý6şŰMUÉß Fë$‹V$pĎ Ž!7Â\m:dG,«Ă˘‚ľ *¦µđ¬ë7 —dOS8ą*ŻkY:ő“SC&Öý ŻV\vÁŞěŃ-[Xqm?#kPŽ{쿬đÚ®K1śöŽ3'™đ3/›Â¦Hmź¬ť[ň /$S«ľ\®~ nzťIlçĹÖ† jă~:7vsś‰xđJł‘ŇGמô6/Űżąe.§!yÜđ€bV¶‘ď¬?Qqí;x|ÜĄUš^ËŚ|é›4ńŐ†”ŞS¤läÝŠ°Ę®ćSą µxi‘HłÇ×OĎ®°>Ë<ÝD nĂĐI<Ę"%ز¤$ÉEřÚŹáźgI¬1y;TÉ›ľąi×ŕŇĎ!¨$|\¸RŰÖ>ś8>:֣ʢXbeÇ ĘOaŕ#Ě˝2đÜŁTA-ďÉ`ÄႯEw]Aľ^ňźŰ^WO‰ŢrQ‘D+WŹO|h)ĎW}˙¸†ŹMüěľánń|w]ťh°ŞAGôĎRý‚X˘GáÜ^âDtśŮ•x˛U’dt¸S˛GůźgŤ‰˝W›•7“OřÇąĐ[ťâĂĎěh’>íx®‚}YÄ €k %םcČ-­ĐK5Ňy~8v+sç»°.őťy‘P¬÷O>©yú~śđłUmv®yË×őťZ{ J›ßMG3a-FνŇiíŤDî¦îr×KŘŰČFĄ7ܸąţrµ˛ůhĂu?o…ÉĄŕ Ędý¨›˙3Ť–®4 cüJgSŕł8śSű‡*[­‚č»ôŠZd…Ő„łąDC¤˛¸˝6Ši„LŹźŠśýűé‚űˇѽ؞%hâXŃ©‡ŐŐp‚`·yó1n\ńöĚs4{ţÍo3r™­äN#Ů”đ%űG×ô~é›ičT)‹XÂŽÓUĚóÄEîÄ ä|vţë#/'0˛EĘŢ_–:D ĘuĄűyôŽĂš«|•뿤w Ä€‘yAłJp@y§j Tą˛nůxž1JE©őăy…ńšrÚěQÜĽŘî …%Jđ¶^OJŚŤ@µő‡ďRşi/&lőÚ¬fjĐÄÖ» 9mąé«Żň4Űí‡Md·&ÚÁ®Pś.©23µĚ#Đő‡0i™ xAŰÎĐ$FŘĐĚXe>N1V?˝ŕřË3N–¸W2 ­€ßěĎ™L•8d_ě«« …š’·±ˇËÂ"•4Żp9ĺčĺčžú:¦^~Z«řunŻ %!š 8XřŔ“—&™!µEcdL4ZŤŹńŕ´ÇőÔ ˙rŔwLă)=ß',öóôB#¶'+=E„Ń+ß‘dc±ĘŻAŠX2Í)ÍôhŤ›Đ‹±‹Oą·Çś|~Ä)5|T”ÎIeřÂEÜ1QŽč^‰ Ҹd^?ŽNfżđ áJµřqN·‘š™î„ęö|ĚÜά0ŲČŃđĆ”G/Á÷j¤4^2`qSţ­Io†ěweŕD0—íLA…a¸G®&»R8‰¶*ůî¸dM,˙"Á°PX\Ş®6c}ča™"¦E#.é­ !4ÓjL]Ł ]Ę#Ĺ"žÉ¤üűvdČ?5ZąÚ0ŕ şBóY-ű…e˛‘,„Ď“s]ŐÝ>ˇ¤¬Ě&B)ďđ‰ŞB2gYË‚–iźŰ$S˝öĨ˛˘|Ö^yoÇYqB5wÂÇy;5›"sŠ“#ćô}¸Uńע`HĎî6ŤţBş©„˙ĺU-.őă‹lÓ+’ Áq“ž!+Ć%IăHú‘®ť±`iŇ=®˘™n) \Ä‚ú"ýöżV #Éőî}*ÂÖ‚:®¶=›‰Ż¨7ŇĆ)îÜ2{Ů­=ŘW`™r1§ĺfî€Foŕ·X÷5 ÷,©şĆŔ?°|'|ö٬ÍÎ Ýp7ěBŘ9úJ´;ŘÎű¬Yţĺ€ăíéĎƶĎpŚ űb ä–SĄáÄ#ť Uµ5ăĂxĹ®’­:ŰćČ›źřŹżPa…N{Ęyj¬pôŢů·şŽÓ´ 3\čwm•Šső;ÖµęőŻĽCÝR=µ~Ë+iüś†‡^ÜylóyČŘIď ÄşyŮ[ËrŰئ(z'qá– Ü÷Ď+›Ýs_ńˇ)6óę]ôRYĂ‹ŽÄviҤô?ő%x,ë@U";mĆ2ń¦…ęčÖFJ0Ňם­@F R&žĐ<ŢŔŇn.L)€Ďě‡FÉ9 yQö6…6FĎo\Ű'Ó6†<¸ZŃą– ?Ďěh{IeNá­˝äńˇ°µŃĄ’#Í%|Ćlß|î"ăÜâ8”˝çJ˘‰©ebł±xIZ%î{ŐQ¶hrŇCĺŘśđäńÁx[¸X§ý‰aż‘7Ň=˘4úůů‰_ŰcťŃÄÉ©xęHXĺ4“ň Çj?eťĹîA1JĄ†·,-Ĺ_¤“Í$Ź!Ě8Řv^X䵋^noHÝÓ|;¤Dgč&ĂJźvťxżŃß01))šě‹°¬kőHVHIá#8ľpM±u #ą — ±D`W=Za6áodJ†/9=čqfP&‰3ŕ„Ýö™oPŞô HaľA­şUĄ—$°4An/»ĺ Čp?TMhč^äłN^x<,±2"%ř&cäó|±{Gü×F«Č,OgĚ\ĹÓ:; 5€&c'ÎăečWżgż7%%›d“Ěo PY«©óóŐe=ëŠĚ÷ŃTŃžxî!óęFK÷‡‹Ř 9M-B řµ¶+łÝĚń(ŢK4qdÓĆ’ •©$ľ"Í-޲ĂeˇYŇMDy]Ph \@_©2Ý­ p·WYîałN+ŕČ!űůł˝ĹoDb‘Ďg aű j:xąí„”:{¸€W „^—p…c"„µN_3ML晄Gj5Ř(„¨!ţ:Ö—\WęjąW©ZůKq Ë `N”đé-­ŃKßv‚”’çČ#IŇÔę± S]ú‡rC°·™ ł•qú@ †ÓIYŤË#%˝kčHµłh=^6ĆNúwk‡ÜR_w7Tţ §UD endstream endobj 268 0 obj << /Length1 1144 /Length2 10975 /Length3 0 /Length 11747 /Filter /FlateDecode >> stream xÚuvs|]ÝÚmlŰٱµÓŘhÔĆhě;Ů16¶ٱm[mlŁqcëć}Ď=çÜďśďţÖsÎ1žůhŽąÖ˘ˇPRe3µ7IŮŰą°p°˛ó,mŤÁÎŞFvźYT@ć`Ŕ;Če„DCŁfébú/úťpąXÚŰIąĽój`€Ľ‘Čŕ`çgçĺçâxźłsţÓĐމ ädikď Pą€śl,íŢ)I{°-ČÎEěŕ`c 2U9ŰťL@Îüł÷Ěţ;*@ÂŢÁĂÉŇÜÂ@Ż®ň…‰‰ůßŔŘăź @älin }ꏂlěţŠôîBdrzOÚô/[%3ŁŹ¦–.•  ·pqqŕgcs03˝c¬Îf¬v 6†÷D?Ú™JŘŰţĺŔ鯞IZ:LŢ‹ň`űĎľYŰŮ»ŮyýlfigúwI¦`6u;KG0HVň˙żCH˙ĆĚA..v ;;r€ÜM,Řţ ©ćáú›äř 6˛3őńr°wŮ8|,Í@ď’—ł‘+ŕâůxýżÄ˙\!qpL-M\Ć ó÷cř·÷wdöʵĽ‘‹“Ą;@‡ť•ťťŔţ×óŻ™ŢűšÚŰŮxüŰ\ÁČ`ÓVĐTű,Íôźµ˙ËJ\ÜţÝ% Ď —ë])ďů¸8˙ÓŁ’‘ĺ˙Íýß›eíĚě|˙Hü˝c˙LŢääü®Býß‚eüOO ö.–& ýżE˘ËÎĹţ®Ź÷ăĎ˙ŕ˙W ýg )°ŤÍßőÓ˙ŁpŔ{ĺ΀πżj·1rú/s#[KŹ˙eĂ~ýCç˙?˛.F6–&bvć6˙j“Ął”Ą;ČTÉŇĹÄâÂř®ngú÷Ť)Ů;[ţug,\˙Á©YXšXŰśťßŐ÷7˛3ýŹíLěM-íĚŞ.ďú3r2ýđmvrzoĎßôľ÷źk3Ë÷A w ŇŇĽ˝‰@UmPű}µ±ËŢOÎ>nőŰ70ů¤(ČV¨^ëâą7ĽI™’Jc•:ĐňĐ!±ÄŁxܬůÄ;Xá±°± dÂNXëřQÎč'/Řűâ" R˛%<eÎ(Ęnµh„%&°TCěqýHďµ÷áÉĘň+ćřđţ(ĘŘř*óĂÍŽtJ˛[|KA–ëjśz “ÓFn<ąĂ®čŔ2ś›ďGĺň› ‘Fr©=7&Ö*ááďśč>Zt|í„ěf.ϡۿbG~ÝaśE#H#]CA# řĺĎőŮV`É8m.ŻżcŠ~…w‘EĚÎđظʍ2|Ýł$+‡Šü^zs{ĺľy8¶Đ±hove®4„ÓŢÜ˙¦1o‹ż6­7öŰU˘·óÓÖÎ8DŤ.„2‰ź}UB€«}ă‘·¬ŞAOţwnéÖV|b?Ďę ±-ý:+c3ăČŹ˛H÷©žé_ęÓÂ2+•Ýö{-í‚ĚŁĹĆx< ̱ŻúpÖÁKç_{Ü‹dw«CB î+¦ýsŞëT*¨3ň RDkĘD97A˛Ž .DöÖά‚žfCF÷Ĺ4,ęôJŽŚôáÜvÄýSęzhźZŃÜš9ŕkNd(4JťÄŹŞ‚űŻ•Â˝~Ü6e_ibBű‘ż ť2†E ‰Ô¤á~şqĹŞć4”»ö,6NRW€Ö «‰Ůč×ÝŮ s`^CéWő·-b4żE¨í'µ(嶡˝%ř ·ö+9ř;N\ ľáWs!´đ…c¬a¶J4´hxm}ŚŞobDV9aőĹ“/ŢÝŐ(H…űb“aŰaÂ×űŔ 1p·¸ż¸9OŐĽ 6s+ĺń%ţ<GÓ÷±f^xíx7ÖVv®LÜş–šuhĎz7Oľ?ńVĘg6-MBű¬YßRö^V«ąÚ=`üg¬dśřQw[(ŢÚN™ĚĹŕTl–xÜLá ĄvDSH,ÄŚŻ®n‹Q¦vĘď+©cšΦ¶w°bşżhđ‡ PwőƲ:ĎŰÇ'uŠ:µ´jőëÇq¨ ˘—iŞyW,)ŠZ“Ř&](—ÄFîCÎV± ĐcEëÁqŇ~‘ß:ąfĹ|´§ó7ŕ¨Üř™Yś0Łě8v Äꎄ">Żu ytŹDPüň4Ťě1’ŇŇzfĽ¬˙ëŠě"ßě¬Ó ăđň2ťWD5?îO_ĂŮ~OąsŁĹżÔW!ěÜŰ@ůĎ HŹÔ{´6$bô“čw—ęjŚ­Ŕ¶ŚŐÄZćCkĽD)ÇÂŞ`…˛aHŃöaülZ< Ý`™Ó‘Ł÷\ÖäyőJé’đIJi¸¶Jx Çiaçî*Uc)i/é’Q̶-ö‚6qˇ†nŻĆ§fXsô­ĹLbŇzÄ'óü§!*!›YÁÖ’,­–J{˙vîRű ™R¸ŠĂČ\>± ‡ňvQÝ‚¬*5DeÍa~•9&|„,ó·ĎňÉażŘםh·`ľ@Ëĺ‹oÂQžÇE`č…Eľ‚1*Rľ#ë¬÷:±O'3°.-%É' —¤®Ű`t^®ŞxgtÍ3Ś ÁJˇę#YEćÁóô}©4›ăÇx4&w〒źÉ´ç5ŢZĆő›iמś Čr‹ŞYcR3¸nIb=„JźŃŽŞ< ľĹQ‹<üB2°Â·˝©ŰOÚE29ęĹ=E;AŹ´N-ÂqŠ‚° ëüÂ'ŢPăJď´ä­Ř1Í®qÂâúT™>OBF7`·5AkH÷ą řXč­ž»˝Ó ¨¬BÜ•#Řúäv|CŞ”?ĘË=í¶ë÷PXż`ąX÷¦gÎ~P° ;ač*7v‹EëŚLD ä­-ÓÎüĽđÓY3u“áďt8_PG/śŁb 0/âkÄKjŽĺjÎ]ŮLĎ…ô(8ÉżÇ5tN@ąŕVUp3Ȱ&ţ`$Đ ţ60,/!BžĄ@P˙šw Kńô€§­ÎC@wQ7¸ś‰*¤˝[ŰĐ}ÔűQÉÓY#ĂZĆR¸QyTUKÓ™#‚ ľTű›ËžĘsćş®,çę°ŐŚ0÷K>ŘEláâÜâÖtĂÜ>äŁ0v~[§ ČĽ‰WQ­‘ú9,¬w^ÓŤs–ŃĐZşćdŤY:Ď4ßO E®M=ĂÝTě^>bLK˛ôxá’›†%Ś v+ŐŃ»g»ý<Ă…Iĺ„ —^TőŰysĽÁú75ŢJh0Qqo Ëă{üLtŤ«®Ą9d {o nĄ0© ˙O‰Ý˘g?ň‘ÝOALV¨‹°-śĚ6ĂŰ.ˇż›™† ´„¦éĆŻŤżsV%ŢŁtţrśµŃŞDĚqĺÜ4€NG\đň0(ÍHőć'ţÔ»·¨!¸0­Ü×aÄ}ÎMNŰÁńqH7Đ«ó«žĚÚĎřÓ a%řˇK•ŹżĽŮGź·I\NůNQf¨=Ćä×ůÖ”]8,Y·1§ßĎôŮ_˛Ş¦uPŤŔsćÍť!ąĺä>°Ó|{˘”wX‚¬,çeéŠ×§úú$ąʏřü:‰A‚˝ICŠH¤„¤‡ç»Vóe5N,w 8§·X¶ÝüÄí…ĺkĂxt·ĐA‚h,´Px†-ZçĐ„lŇ)ď0ü úŹâ/˘C»ßaÖKŻ;„‹‹OĄŘ ™-ňśwŇŠ(•îTBĹźy–C¤ {’9»OťwS'üÚË [ťčćrűk đbsDo‰«B:Sî—‹v5yőĘ8”gÁ_•cBć¸CSÚ #ĎýzńÜź[+^©ÚgjVĚ6CĚE>y2¬ŮsÂ}=ňˇĐá4–·^÷‘6ĄěV×umSΉĆpQtň‹N©é67Lݬte˛ôˇ)˘‚>id±v;®4ľ˘ß°žđ^Űr6żŽqýNßć…J4ädWT ë§łż`žË;l[\ĚV÷ăˇ÷ß ©MaHčDmttj1âéŁţŞ2 ťrîí€M©šŚë*ÎęjĚĐxËć! x1Ësi tł3°kXşíů@¬VIěĂ\ěź$bM Z´Ń\qń¤VŻ'ó®[”¶ŚStŰţ ˙ĚŠjë ű†ÂEżâtđ%ŮŤ8óuć‚™=^öŮ] »Ö}Ť”ÓÝ×p6G«`Ó˙w‰zí+2xg`QńóŞ´m'»Ń^cq {ÂĘ8ô3‹’ÂuRaĂ\)ˇŽËÁ…‰ ć`Żę€ŃĄH8F–U ~ąµí˘˝M)‡PYÓO~ŘO-¸}¶qśV›ěb2t[¦x ‰A¶ĎÚšŇÝ‹lh!&XK&›X¨‹ßS€0Ň!ZĚl—„{ĺąč&îŔmˇ°E¸ĆXŇô<¶Rć =hXұIłjçNĺvJűĚíŤ×Lű“8żb™¬´”bÂ4].˙´–hp÷ćh¤’ČIoFDa Śe•(!=›<ý&,F ý«×N)ßßw&—9›˝EX¶sc:¸ŻĄqb"úÁЇĄ#¬¨Ő• Śx[o#ćđ#ŰŰ)§8§oK‰Sç— ě{¸•ČíľeÄ‹_hÖŻ‰żĂÝóte=RŤŚĄńaäŇ«KŘ“çt|g®Ľ&pgrKkń…ĂóŽ|cÄíŤsBÔ34+`ˡÇć‚ä?°÷*âaćśxg \Ô˛%Ó•QöjµÁł ˘WÝmˇ-^(Ő|pčŕ:ënů¬Ů Xá\•ę0o¦ĄoóD·;űóü0%ľĹśŁD"||rŽ2ś!PÓ#ťŕJx‡Lm'éyƦJY_‘׆łŰ˝"¦ć2xŃvTy/ł^ýÜ|Ş9­ř6l:VS{wÉ8ýńfĘ™B®źËZř§ţ×kőü0ź%ËĄdĎŚkŰ#}R˝`eiiV”•ěą”KŰ©­e÷Jw±‹„l:ĆÔ?µgÓNë;Ś’űšäĘĹťJź‘Ĺu”–){!Í Ô¤Zń“ťŁ>Ds°VŁň’,ýŮd˙Í>\źč§PX†~m$d.ˇ•uűmMpšˇëř°Ď[”Şgs¶ć`›XQ˙.=‰ů‚>»]䣺.tqü†©{˙˛]›ŮM—Íś˝ ľ9ż&ű(.Ǣ\‹Ń‘ś˛;Č×XütşĂ|Ys:Â6‡çÓçĆzŇ?Ú}6::cEżÎ˘j™|ń.¸ }YË Nř„ŐJ e–Vp+ÎÜ»ÖҨüQ«­˙|•ü:‹µ©ĺHŠÖîe)Ą…t»-QÄ\$FWë„<ýő…‰…da -›řŐ¤Wř˘ÉC}‰çöOŔ§˛;6”ú*Ý"ŇčIŕ#¦á.X‘47<śÓŔt%ÝP[aťć‰d‹47ßëZ!úLé_2śO<Ó]Ě}qn©ťŰ«kŮ%𲡆e>ň a†Ş`bÁÝi’TóąÓ'GĘKSĹĄěd•iS9ôëÉHâĄڞů±Ý˝4™mÂČ^˛C3Ë]Ń…·ÄE‘ĎV˘gfĂIďŃ&źF(*,b i§Súżü`ž‘Ó<#}3nĆ;ÎTĺŻÔ·Ë¦Ó ¦&-"0UÜĄEŻ­nŻ^ĎÚ8Â%ßRbO9_?qeMăC7㦻ˇ iôi9©T¤(8žčî«9ßú•îk )ULĆţžéĄ9r˝=kŢPfAĐ„\×Ě@1dáŰĂ˝«Ts‡™@s4}ŘÄäň6S–˙YÚ´-ŻiÁćďŰŠvf'‚7á\=J–‚R+ýaéS†ĎWgtk>Lözި,Ţt„/şíى|ô#L((önÁLľ¤Ä ĂÜúä{Ľű3Gń/rž yَ˝ĄŐÁ6ڬéŰ»y=pŻ˙~ßIÜ|®FVÜŁR0Ň&řţOĺ|8tÁôŤˇÜµ;L>ű¤(اAŰs}ůW*ëěS´¬#˛P/+­a±ŤMu†ÖÔliv˘˛­J¬żĘĎ /÷}ký§ +e®ď˛.g儨†I˝ßt~÷4„ä­ü ´Ej݆§cŠ´Ă§Ż3˘cG=v 7o7(Í‘őô§äN˛î] †©dÝôç%ůÚçJÇäÓ9©ŕŚ;ź}©ĚmôôVĚűČś9!şNĂćÔŹqčJŇKFűţ<• ăft]‹J»Ĺr™a<eĄˇüôA™˛{FoŤŤńů™x° …K ĺxŻŰQ’ ć hsŞůĄ{­úŤ7ľ6RT™P34oU%“´^/‡/=éZA±ÁüÄŃX·«ăIĺşgřő¦6Ô›ŽůŮű;GMŻďŔµCȤ›;Xݨj+uݧ¨ĺ^}ţ¤Âó®4T  #{şŁË~×uGQ, ¤2#së gŔÖľ`ŞV›ú<ă6‹Í·˙‘ůŢa„ëşčšU}@Ó-áżűk)]! rÂ(ęéa{÷¤¨Ŕ·Ůźfź¶2ÉX í® _Ö8Ą śµ+IŚÍ3őµWtuR]±X®eÄëUŁoež’~Ş$QnË-–袍ŁĹŠżp!ô›š“·©Z Ł€łˇdR®]ăC’ŁrĺYqotÔ>iÝő"Öm* GŁO˙\i·é:‹šdsď–g&0ę|Ű©ôCŤ´ĐČ–ćŁNŢŔ'&µU[uťČÄß§»•W鱜€…t¸˛b ¤»łü—©2śT$BJD×$Ě–ˇĽŻö)·妨˝e±?ÄŃ›řÉ5®Šô„Vq_'0Ŕ4á$F7J§ű܇Z–˘AymѦ@ť ’°·Ă'ŹG&ţŘţé’ĚžĂMśÔ;QfΡ“ó6Ç(•‚őľś}]ČyŻËŚjĹ>ŤU¸·mŠI´ÍćmŕÂ×üߪTXţku·”}+?ouP[‘Śúúź<ĘëŞYżśŃ&e Âq^i‘–j«8>Ý+ęHŞ2m,…o%ŠbO‰Ş´Ą…řęZÝO:K¶rß'îŁJn†#•.™MNÝŞ>J{Ŕ…Ű[^Űďó˙†+ÍyÓdÚ¤÷«čű)Ő:˘ĂŹÚťđÔBőQĆ+µÉöNRü»*še·‚6×cŇ™Đď)Ôťm(ß Ó/Ĺ@ôż 5Ó|ž×čJC •:xZďŇ©=ţ őžŰ¬–e, má=ďšHçÇŐÚxFVŰĆs|ńˇhq[tSC"¦–±úÉý»˛2m+X®—üľ]¬Äá—H7áŽ`„»ëQi×CꇩɶŽ8ŹÂÚ¬Łî±®¶•ܲf“±r­M‡1ͬ‚ÄÉÇ릓6ĺéjŁŘ €3^kthĽ;ýµµŘ†ĎĽ?tˇĚ.ălŘŔ¨ÖK„ĆŐ­Í'ŢĹ~*G]DÔS÷¬šţDâLÉőK<çćťüÎ)ĄăçgŇGÂłµy2ľß×ŔK mČĆ·¦mÖŤś}RYźžľ°ÝŰ)ňh¸ÂHy»K'ňŹaÇJÚ„.,Éa Í XzŻ-Ě05pť±˛Ő–/óTw}¬ńŻťtΦ˘ Gó%V5P>â ŤAäČPßö\)(­.łÍüa€ýQ ˝Ĺ ®ÎA'JĘ!+~{ČÝĚ6}1Éň:…%´ZĘňŔc˝€TŃŰcŞă’‘7JqrÔ/ZŚRŚéz™¦8ÝĂá[ű.źÝ!ő —ŕ%ÄE˘'Ëřr»)Yőc@Ćt7™ş%<âĆK‰ý±6¦t¶f —˛Z b_ëŮ„«ł'ü¨Ć÷Ž‘JžD©sbŻD[ş¸,Ç%ÍŞ€ęPFš5 §-úm’Aăŕ—G"]+ŞŞž Ç}Śxří5]÷Ĺ{Ť­ć"ń\ĂR¤L3Aof\–ĺ”Ô“sí!Ş?jŞĚ%F§×üŢkK6áp&ň*An®„É ggGŰŤ÷Ú¶ßîZ[eŞ{ŰQq¨Q«ccĽŇ{čžÔz›É7+L>G­čś˝Ô…»y#b˛ˇ[qµçĎÎע}([YőP˛3ű|+ĄŹŤËG›â9c„O4=Ż>wĘh¬óˇµ=čţ»üíĐýµY¶?Ś(îĹÜŁ7Xąŕň 1Ž—ŮčV,Ą†żN6Fµxt=%*=ČĐÔÇ–gö‡đde{”Ú uĘ•ę—q"şolúŢßqilAé×NĽ¶+Ć;†ńO˝?Eĺ"ç5đĄbd¶( ôě6‹˛‘¶{ÇŽĘĐĆ–źŕJCDuÔ3;çąě:Ú+mÖűą*™*"Cp*źńŕđR˙đĚJl†Ş—vĹ:Ść÷®˝őŠ4X’",sL¦]=†§TđÁónmĚSn4…«J´ţžţŞRż7aŞě˘Ŕěxkš´Í衸‹iť Ľo¶)-řłN”.ńű”ÓŢ×˝űÍňBoĚ^Hw‹ßő))î`yšĄGzşŢ[W8 ú†×äCÝ·Ä8Lv3wÁ%âaô‰BŔ:¨9ą{¬Ň]jMŐ¶'aÄ'ÍsÄY$é1¸d1ő1–WśEąÓ¸”ĘlÇhŢÄE‡˝¤TŹ—ćoäjHÄě“9(zR*’€$Ż]ááO‹ÇÚ’ŇNÁ-n<Ţ=N~ű2KicěwńEaQÝťĹAŮ!¦;ÍĚuĹó!ą–ßlüMÓCK¬‡˝ëŘJ‰š˝żY¸á± ëRlú™’>×âˇ7 O˝[ÖYé6/ÂvFśä{çĺk:·^Ź’QúÓy°ZkęfQµz˛ˇFxóţXf–B’j ײ‘¦RÂ×Äć§É"ŐóŚFŘŹoÂk€NĚŇŢĎ=<×Ú~śkm CíRóćź<)[Ü'§1ýv2’ŶڴÓ˙äX(¶)A‘—-ĺ† ü€I7Lř´â§žH™‘ĹrĺÄą˘Y zťP ‰T«‘ĽeG$ŮŁ‡öÉ‘ú9čŚ*˝’ĐčGďŔõty$âĂť”D° ä5fÇĂą @őp¶Ú/&Ť{nk O›;q¬ěľ‰ą@JłCŢŹĽĐłŢ;ŢŘÖÍ2Ó•s†îB­ÝßÍŽGy:%f †Ęď¤nÚeÇÜýëŤC7\ËJůľú'Ĺz'óŔŻô„sÜzĂ~8€.gĎ…ąw?:ůµeź_URá†/ن.H~:ř‹F7ęp˛ F˙‘ńpG7Őé¤ć­€ť˛%2†|ě"B=¶ďŢ1…ŠLµŇ' Çý÷\˝±›žčl:ŃĐőJZň5–’Zxc Ł Lë;©\ťSäęgńFżr~¸ÍmSrs-1uUV6ÚűBÔIäˇţ,t˙”ÚŹx čBÁ¦4śăůA“‰khćar+÷ÇrJđúB…@ŠŞXŁąŮ«ľwŻ–ńx03z€7Źâ® iđk­łÍ»¦Ĺp, !jRďOo…RNóóý ł+¤đăýźŹnÚţn|îŰ-Â6ÉHSÁľżž›/|‰űZ°ś'”&|ł•)nu Ś6zËéE#s>ČĚ:ĆG={=ď2_“5tmôýĆ$aP(*Îo{ĚG&Ü•á7M†j°RôźÝůBŁŹośß·v 1ą!-?z~äÉđ[™» w7<™Ą¦ÄčŁ%1gˇJžjű/.@…ĂŐ¤ĎĘȵ?.4¸Ĺ](V}t[Ó… Ë50¨ eCĎ~Ű«˘đÍÇg l< íćÉšŹĽZ!Ó¬u5µĺ˝Ť™păZv{oźĆ§5Ź%±IűQ÷KH˘ŇV6©Rcm•ťĽµV—YůňSäčcydBsz›¨2 %Ú,M+şőř9ŕ3«XäjłŮÄÜĘ|×F'*Č6ŢądMXá ?äCŤ#¦Ú‡łwŃě<ÚÉÇť#ŢĽ ¤é\|p a|‹ěO‡őSÍtXŧń\Sɬ¬Ç\fͰëŻqéN!6eÂ…_¨ˇÔ»ý/†z/§·}]5žDˇŤË0E¨Ä ÝŐĎč"°§ő.ó¶QV“áZAXűgd͵•gvâšj­JmžŻX kqi§Ţ?ÍËDxvP:Đúéę/#|' şH2äŮ4vŔxÝŽţůs1ŔÇ(a§†Ů“%E±hňš.r2qşôѰc®Čä4ZO‘lm¶äab~!†a~OŐ¤ÂWrJÁ»€Ë Ů<-W˝ÄÂĆ3 ß}m×O‹ěŁók.ca°zP†˘QżXë”ŰŐ”\Š´Ş"@ŕěŁ"Ëú ćŐ†ÍGŠËŠY]ťE*ď„1­™?G2Ů©± A¦‰±ń/Źp§ěFeš6űSíů*BKÍ"U w([y€îÔĺyÜZ1Q„ežť–Řęrő$v«Ii”˛‚$ĺgsřJš,f>b:_)§ÁÍ‘čśNµqň&;ĄšEŞaf/\qÍŤŔ± |Ľď^ |áěM·Ëü&ľĺ?ĹĆéMŐp*ăäh“›ÇBç+‚ŽúĐNSPř»í’›5˘±Z|/6¶Mb%®u aöőë-MňöĆő´&—ž˘<Ú1z…{5f?Ęč$Y䨋8Ĺ8= ď‰Ŕt×’©ţŞŠ1łm`ůÉžř^i(gmG `ÚužŮ}——//´ĺëz)ô?iń|rřý1Ň1~3űĐ®íVe\lyŃÜ[Ţ4śŚ[éäýučťňÂšÖ Gd\Ö^&*ťŽ©ě2gČaάµű)'“ÝŮ “ŹHŁŘKŮ%RÂňĹ 8Ž\GľzNG˝Ę”®T¦âAĂ×ĎX-Ż·vąĂl;Ű÷Yé­“ Ž Îď0¶lS »›†<…ťŘ˘¦Ű/<.ľóŕŢqĘyóVKzq+ śń•Ĺ9Č}U ađÓpݵ5D˙0ň™•!˙wWmžxzr;^w„VŤ"Ž˝Y‹BHÓ¬ÚčÇç?ůH™,ßw_Ďš&‚ž÷ž3 ăÖ„d“)2v˝5±î, -ŮĂ’śń@ 6ĄÜŞ6zŐ8-µ×„CŁ•sĎ$†"FJ”6*Ľx·ąV:’tćh“R j/ŽîV˘××?ÍęőQžá;výŹh>ěíÓi3ľMg±(¶‰8=)F kď˝X-Śh‡őď; 6űnÝ_Z /@ô7ňµKßbśš~Śš ś0äă$\ĚËĂ´Nlř}×Iú8R_ ĹËÓäÂŽqI÷č*őţűŞ:RС µéÉ›pZT­’{čUé›Wü@|2áx–“[ĂČĹŁZU\CFű1 ßíxí¸oŘĂ”F8¤O[b1Ă7ăŔĺŐK­HÝľ÷űiőͶ1łŃsŹŽě›@~g킱›Ëb ˙80"pyť»Ń—Y!}•Ú 0&;¶n#˝K擄<öŢž¨fw¬ŽPÉ›éĎ6®fZ…Â^bוîSOÓ~wşëČ«jk÷“ßqßčX`łëűv…Ő‡€QQ° ‡÷EJrć%ězěPy¤y)/ćuĆyŤÍt¤đQ`r úËPÁˇř •Z~(|nWű«KA?LC®4Ť´XŹP…ÎdÓđî)ţÍZáiCMH6’ŚžÖŤ’K·íŹžxíAż“x´ˇju îřŘě©}(¦y3Č~#Ą3ňÉsY-”Uő´˘'W§J­}@+m„ťĂ§xś> •ä%x †RDžĘÖ;ĘÉV}°`@X`Ęľş)•űmať'­9ś8˙2ň—š>>cöšg<0L7iÂ[˛6úIAĚʤoÜÄUaÁŢORx°6}Ąň⪱µ'ĺrŐ[Ű 2ë ţ&Ş ‡ žůŚíµ™ if™ŕŻt ŁëŁ®ˇĎ˝żScÄó3HÓëŽ!—¤ď{@5Ę:“XţKbÁyAĄlčk†ĺ+\Ţ~çń~e™śÎáväŁ4*äש˝ąÎ QŠł5í©41|Ę/qo*éăkŞăBÄPˇżš­‚ڵ0—ÓKŇ®%­cOřYQ ˛G˛#8ĺ¶·Qâ= ČVeËs†ĐźÚ˘·&K„ľä®©»óô}€ë6GÄyI0§ż0' € Śu‰őP‡M&ôGí¸Ć2\:zŚCn´>BLŕD&U˘áršLIˇ«ŮËďVľáľd…AP<ŇŚfč»SíŻ)((ŰgîÖZ_vűěpQĐ)öfŃĽµí]Ą¤*ą5•ľÍÖ5]Ý0ˇ@w%şÇa"XđČťZËŞęP׬+FŞ×…ƧڶŠ/˙ŽbIüVYÉÓ­ě~Ł€ď}8Ń{ ó®Ţ ˙RiÂP®ęÜŃHútëüc‚'4”´kE ś÷3ÚÇC‘2Ľąăe]đ8¤V‡)|"đ¦Ű¸Ä‰UšXCŰ[zŰś_’Ř7`7î‚Ď!l¤Żwĺ±UÎëSU›ú6Çű3¤¨nç3çĆ(aăZ˙©[ď×™â·Ám3l~“^I8âČJĚ„p‡ŞŮ‘ćďÉű¸źo˛ĽňEެM”2·ük¶ ôć“vćD®ŕ˝ ČŇ,kôF2tAäOÍmÂÇÖG˝_Ý­ dXIú ׹:±›đ÷7É$ó˛IńĂřšđŻĹ"šĆŽÇaßt¨(^TÎ}ix"ĂZŕM3öP¬–¦h$¬x‰Z㳊Önż9{N6sa›ĐŻö ‚J¬_Hfë˘DŻ.ŕŘ—JŁĽM›pöČżđöŹş©CňÓ×˙™%=˝ę¨iîÉS—ÖJÓ6ĘĎTů›'‘©˝űeőŢúĂęůÝcĚă ‘ďŻZń©Ű}]€¨™ŰŰ´»:e´?Ę*XdŔŘÎOzĆ#' {`®Ł ’¦Ú±qĹ™„č“ýÁC®†jŞšŰ]lŤż©Čßůüöů35‹3ĆP"'}ćÜŰlҲćk{Ö©ĚH©źŢ×3G OK,úŰžŇęÎkrµQžTWc”[Ý™\zĽLblŔ;[ËĄMŮ·]1×Rpč«#]Šb›S_ Lá3Ożsörš=q‡Á» MEççâ.^⤮’±$ŻŞÖ+‚Őz‚mŇąx&ó¶_2;˝ż ucÍZačý†Đ±´Š›,.¤ľľLf¸KüěD‘Îď€â+˛ČËÂĹYfĚťYŘ<ÝźýP°žĐäÂ&aB~9đšěžŚÓËä”K¨ÜđLś•ä^Ĺ4 W’{Ůqď/D§¨&°¤íč?ŠžÜZZ÷O4p¨ďÄ䳂٦ĎÔĆČŻ}ČŚKFaP*Kě8ű?DMř endstream endobj 270 0 obj << /Length1 1177 /Length2 7929 /Length3 0 /Length 8706 /Filter /FlateDecode >> stream xÚmsu\”Űö>Ň%%!0twww—0” 0Ŕ3834H#ťŠtww7„„‚”t(!)đĺśsď=ż{çóţńµž˝žµźÍLŻgČ-oł«Ŕ Hn~> €ÄŐĆa‚jq€ÜŐ‘ Ŕ Âaf6‚ ]Ŕ˙ň*ÂÁ $U!rŚÝÚ 8@€ŔĎ'Á'&!Ä÷°ćüw" .ĐC\a>=0 w@ %­»+Š4twss€í Ŕ;ÜŚŘ?třĎ'anŢp#Ŕfl`ÂÎÉÉőw„_\\`ăýo F@ –‡…ŘćöÇiŞ`(ţиÝązö e;ňŮ6G$ŇM‚—×Í~ń ěy `$/űCłĘP;Eëś?ć§m„yóţÓ ťˇ0O¨ď?Bö¨ÝźňěÜÝxŤˇ—î`uĄ<„pţŽ9€‘a>>q>1ř%ěeëČűÇŃFŢnŕ?Aţ? ¨ťżŻĚ `rA€ý!öŕ‡Ž/ä áî`ß˙řď??Ŕb‹Ř€®äoö‡0ŘţŻ˝6 ‡xĚůxřřř||˙YY>\® ęâýwşČ ŕŐŃ0S×—çü'ý˙ÉTP€=Đr󋊸Ąüü:Ĺ…˙—UůWW|«CíańżšÚżx€áWŘţ41;ŕż™t`H-Ŕö·a,ř„ůĽňđă˙G#ýţŹvúß3TÜ]\ţśŰ_âę-Ŕú]žČ3€ŘţU W‹÷?Ôýo˘ ř/ë˙‹îáżŘĺˇ.`7żŔ_ABâ¶Ó m˙rÉ_qc¨ÝźO¬C@ţxĚ%Âü˙9Blťˇ`âÁŠB`¨Ý˙Ş µ…ŮA CäAp»˙ţ€mÝáđ‡9ýySµ˙ŢŰCZ˝Ŕ¶8 _`¶’ˇNőˇť—µňԞܛ‚"Ćç÷îtB8±.¨<Źúu(śË¨…ň~‰˝ÍRŇs”©6GÓFC O VŽőtWčâÁ$& #~¤IuŔÓ Ą#÷‹męo€*1†â]ή˘÷ÚúŠs łŚâ8±a8Ś,€ćŇl{çĄ.5mEA¶îÎvqňëŕ#]5—Wú3#ÝJ|NÁŻßájô4şbŐ0Ăm>¸ ©ę"¶žý2¨€/0®Š¬˙iC ,•čď¸věŇ”ëFíĺ*ŠĘeÝ>ĺý{·:Â1‡A‘śHłŚG@A1$¬ĺ*ą`‹Eť>›?Řő‰mOlž[j˝oSăÉőͧ,;—‘Â] SuuýëeëG±ą®yý©eLčŇ:s»™3"5ZĂ:ržÂÍtŤ.]ŹNí žľ‹8¦Á7çl/©ľç˛öhťÓ­·^žÁ\‹× ˛I‰ÔRo;;G2ŕŃPáNЧŁ(ďu!É+UüpÚí+.ş”ë×rÁîC˛‘™ěâňÔjŮcľ©ŹëKcÄ/˘¨qŐ¤%G¦'1yÝÎG€˘M-ą9€ń¦¶—úˇ4éŕdŢËf†KF‹”î¦%qµ9Žűaď|ÎIÖ2đXZŘxŞ?Ç’IëŇ’m?#®kCo\ĘÇN€üj†[¸’¶ ‰ú|ѧ¨E~ŢŠµhOŐľÁD<Ăx#-[Ďë>ßW–`:Ęâ9ÓČÝn ¤9N[~ZEńö)jľ·ÝÇ_ź]¸Ď\Ł–GŻ\;aŽNżĺkEťe8­*[üvT60řc–Ú»mäY»Ŕ‹ŇČ|wŽDÂÖÁß ©ü¶?/˘”©EďŘjoh:NřhÇ›ë©äÉŐ&§ ¤§č5“@¤0o…Ʊ\B ĄS:›átíě×Řq»t}3ęO,<}ŹPf%ÔtŮsšůŤ™€U›sş7úVµüĘ` ż‰x,`—„±”;¦ęÄřŐ‰D­ ąń…!__GkǧśGçčĎé4—iR»t‘J}8]ëŐ;Ë !Fę“HĚw«@ěqIŞ:ńÖŵá5–ă«=źť ÝĆ-H8«1—»ÎĐ5íń+QkŠn`T.ăÁwMĺ¤6ăíd'eňd˙á!Ő—.E(­©1ç!ćăßuâď9ÇsÖőy2˘_PóżrßÜÔ&Üç/ÉőÉGý°MUŻĐOü!i‚éÓŽVĚ꯻ęĹćú Ú'ď°ľi’µż‹YŚz}BS^¶Ľf·Msâű˛Ô‹ęúús?ćŻ6¦%“~ó8eˇúäVezűđđF軟óä 拸 ŮÉ<ĎjSâPQQDśfˇŘŮ{ĹPCpI˘"—‚éh 5|€lűž$+­Ęşt:˝GÚ Ę•§îQ^o¦Ů륲ťčŻ2yą9?öGŇł&úSשd­b’ pĆ…pę–Π䵺şRËŕ1*ş\’~zŠG€˝a:Ŕćf3 ^×RYŃ3ş=Ľ|TÜŔăb:Ľ÷Î_„¶ßrŻdF?c’10ÜM|Ň,ńA$nŰ:ŠÓęBÝű‚ý8Ă÷ĺhM}đţ9Ť wÂť”÷´”u2ňČ“łľz ÜPł„ýÇű*=‡ŤUĄ©YšPŰV|Ąc¬"G#S1‘Hí Ś ­ŢWvłXÂÍ*7ZĆIŠ 9^,~Éůrdc3ŠÎ¸Y«hAÝŁPĽ«u®čÁ9ţí؄ՅkÓńę*‚íŞl¸_@ČWCĚŕŚ»Â2ţ¸˛ł´@€ä‘ż¨ný%0Ăđä÷ÂßE‘Á!+\†°PsÁ4é·čÔ™Ü{Odoy9GÂŇĘwŤµ§ç¬·o¬HX«ÄĚćšŕsiglMĚ zDŁkŁ-Ä‘2[+řJ˝3“Ă^C3[לŔăÇaŞrÝ6LÄ—P^Ż B`IçŮSˇ˘u•UegIşÄł-˘_ůŇűĘńnŹ{qNć«ăń‡#`™éâ¤ŮŮŇY,ŔĎ#(wifg.7xňů +ŠűO(ćgŮzcŐˇĘ ŰIěé:ŰvjźĆi3#ő-Íęđo†Ö¦6Óu™9D˛cę%K;ą3bě§żŰ7®…ëHö˛dDí eě`8CĆW'.ÍC'44Ůö§… šsKŮÚć šŔrĽq­ #ŽĐ XňóPř+ô®ţ˛pąÜÄ˝NwçRÓőŃŢlýĺ[j ÇR Ô­­m©U‚Ő5MśŻD$4]íQßěS;Ľíë Ŕ°nm蛨 ޤޯeeő`·!ßÁͶc®pgŠbd]q‹Ő[ˇ]Čç}”áşÖ•Đv±Şn÷˝é-ˇ¶ĺzcE¨Eęň´ ‹Ö©ĂĎäŚĹ0'Ą§mŮń»ó‘ŮcŽ j™0ú–ÖP^?vĆŢ‹>·ţÜä°ÓT×îł 1QfŚ5ĐSś(Lőu…>ÔpxRÇăk™é~×™ć©Ć.rÓMű1uçÁ’?Ţtý뮣(đ$^¶r¤ťRĺçĽlj;f.Ľ[T¬$Őx˘„…8żŞ-GČH^ŇóXef*•f#˛éÜÚŕ‘yQ F;î#řňUďiËŰ"ď{ąć#·1[˘Ë±JţÔt‡Ś^»~§“‹ÝÍŐ t ÎßżkˇŃ óoO\Ql‹1?Df˛Ił×mŽe—¶'nĚü†żç¬žŮĆg¸šS$~.‡“w»đÄldş[hlt”9îs=…'¦TAE|kÂ×,–ëyş·É#†l±\dâcßă‰Íbg'{=˙˛^ĆUĎQňŐOHŻżL«6Qv®K\APöbe5“§qŤT[ĺĚ[ügd±§±S“ĘţŃ#py&č#¨ľ‰Ú¸.łT«úÉ´ę‡ŇŹlą÷“sôÖ6R/Ű^a#Fd r _"ä“Ĺ÷A˝OißyÄz“˝Cŕ$č‘'‘¶[kďT­ť-&ĺL®sµE_uÖµB˝Cźb·2~°ň¶7ţáŁdńj,öTŇ“Reę_kSä-'´dęJxřKŇú†f Ż.Ł‹]ţ4€®0ć'QahłMěŇαö[•­©‰µ ÉĽ#wXšd\8Óâ|ó#äq˘SDoľżdůĆ0‡Öu‰Vz˛OH!lăŰ«v€“ü‘ČI5p´ě"ˇ#‘NZhĘŃ·˘4ůş–qÓ› ÇSin‰ďW^÷dÔçk2íE#€ł8ĽŃo/şy—´6¤OŐ¤|)â&×ĂšťĄÔžč÷͡ž˛„°v‹@$ŠČ#ŤĚ\íŇYý•É9˛s¸¦ŻXŠ[ŇÄŻazúbJaçNáÝ)ŽŞr§|,gŚL†ŻŘß§ć¨íÔ–ś°'E›‘wD†B?\‚-¸âÍ`íÔď˛máe±Ř¦”‰ńĆq?cńŚź{Wă}>;OĽŃ!ÇSX®bfC˙:GD˘ý%Kó{DTËÖoť{8ˇ´‘™o_†3UĚŹBľ—é00Ő+łÄŁX_/ŚŻĆdRA<ąăúOß˙ÚEç\-¤†P`ŻűŽrĚşŇSŻ2błcÖż ç ćđÁ˛ ťvkŇ'}t}b$ĽZ=R.o>ŤŢ"Đ›YŁvł.‡v ¦¬ëACî4-üVMňZÇČŔ ňÓŢęDŹ>”•śVŕ„4ťŽ‚ŞvąşľfţŇ (b ú•j­ZO_]Ú÷Qeđ©txŃ+$É+/pü˛Č,®=»î„Ü}†şđüłýkmţ»0™ěŘŰ §a™ţ/qé?"éÉ®DŠv nňéQ9ü?ć娜[ĂMx)BN{s÷6zwkĺ'lc‡ůkŠ{íó‚ă ó˛jÝě™EĹđTŇ”đö‹ăc­v5‚oľ‰zWw^iěh-Ě=3e/šűŞĂäŇ<¶Wú˘?`Ž‘KFcŇL(Z§RîţÎíÓµľBöw /2¸ źÉO¤T©ť¸őČ^\ŚJčDŹa·Ţ·§H ]™?ÇC°+¸??Ľâ+ň+ťqmĂĹđˇĹʦeţ*Š‚R^B"ťm˘Ů3–ďŹfx»pĺ7pR돥pú,ČăPľżżgݢ‘#í9ç˙śrĐ”íŃŕI?ůGŐHju‰Ł›ĺ/3!J¸ŕo;ńÝ€ń”2ŚOň¬młP÷™A.˝T‚n^%FßŢů U·Ť–5euŃ®0ˇąń¤¬Ć^tI3‘€,Űš-ăŹ#í<ůS#¬yqeqO$\ I# ¦öo›„YuÝŐ¨ÁÄľrĎů˘«©x7ÍźO[;——ÂŚćŘ퉇ťž%±âJ$÷6xśŃ-ʏ4WsgRđ县v†řmŁ#Ë{`q77Ľd}řPK&”n±˘¶§›ÓŕC‡ˇŠŞ‹'c±Ľ<ď˙Ađ‰1śăSĘš­ŹN™TŞD6Ő¶n™eăoűĐ])Ş!8 :¶X'#ţz­XDôÝ7F™.ą×—u2˛W›NÉ]żrÝ`TĂ_\> K$şř%Áî9’R­Y.>üí ń”‹ź0—ÍęîBO)HG&=Ýd6!ň; 1ĹB˛ŠđŐ”NŤ„Ńľô; ž­ŮaŃśćÁFpĐűpŽyąGR ëkŔRŮŔˇgúv/(~îę8gňc:±˝ĺ~Nu‚Ő}ofK÷ˇ*]e»Ą›:ŕtŽ‚ţ•qôQ€‘eTÁa@PH;ŁYňËÚS*‡cÇ×2¨ĚľGBúŰĺ"ÄčhD­sáŁćgĆd}˝RákŰ€gô„^Ţh*ł¤á0ËWĂs’|řQ\Ś˘$<ˇŰ!™wůq»’_5yEQâLŢĂé,§6łĺ¶r˵ˇ‹-ĹqÂ˙ĐŽ­MUjs•űYe  ÎugQů†ó¶Ľś!'—ő:…ô`[oÍÚőŮŇ”€^IźrË+…ŁĺÜź*‘4´m•Ď‹ŰC! =śÜeöp•ůë$ ’oŹo‰żĽoëŘ•V¤_ďč&CŐ9h3Ž‘r3O‚eC;™ň†âmN’«“˛XŐ –Fě^ÓV͸ŘĎŹjcJ5¦~űţĚV—jnő‰˘LôdC†ý'Ń)ş<>Ëęl3¸XéwâÇČÔ‰×y’Ą—/‹ýµď.ô'çY©›0šŕËń>łŔŢ:Ĺh F˝Ů˝%ËYć»/ßĘm8:őú‘(¸ŘĚ88ÎĽ\$‡łď,ާÉFóÔÁ–ńĚl’íCçqÖlx˛-hČĺűĄN8»ć 3ĘL~Ęą:mĽżk}w·;{Lgu<Éíuć„´<84şĽˇ~/ÓÍ"¸§ZW˙˛‚Ă:«b˛Ž7ňÂ,­ĎóT”í…AźĆkSĎ“ö\»DtşpăëĐźä¨4ěąvžlďö\±DÂ})Ö}ă_>1ť\“"M­X5JĐ@ćĎ;×^T´Ón°°mč–bNxĹY±[®Qm%=‘·çÓěđO yđ‚îţM1¶uߪäşű1ÚG¬Häě““ť´ěÉű™Ŕ%Y^9\vžqšlâYEůjąčě«–$•nvúZCťˇţg2e$Č;J%D ®ű¨ŮDÖžŇhěOLî±Jq®7:Ń Ľ_2hüRÜT¸(h+«Í@[÷»Ś*©ŮěŐ,ő…b?\PöµVjQů‰mj«ý5ˇĘ2D1(ţ€YôYşę%Rľ»Xgš±!¨ßĚ3ŕx˘-nĘ ů}ďe>YnŁŃ‹źá&Pňˆ˘ë(“ż>rÉJĚ ‹I‰ŚŰçĐM÷W*^ë J×J'Ü)iYÂd[ŢCm[ă¶žŃÓRŰe·S3Ľ xĚqŹd˝›_0¦R‹•®'YaňŠ‹8ľW ŕţQčŕÚ>J‰?%ä4ăضĺĎwúĹ[Şh8XeN¤ëô‘'z„*ŠŐX wˇ˝†J>ÉţĐDÁł6ŻMC2wÁë/ Í˝¸eEĎšÖŹĹh˝ĄąśŇŻ°ÉŚvر,}5El”r 4A)ŔÍýq‰0ŤŞÝĚÇ4ŇźĹÇŁwźçx„51FÎčďú.žöç¦[*íîÇ“íBńYąV­sŕşžXWEćCüX ŰB¸L(VЦNžĆó|bB Ä›”b¶)‰ܓմŮԻŤŢ`C§+#SÓ«ĺ"i»°ôAŁ­b‰Úlâ–xočľČŢbň3ßÓ›|ÉA)iŤŤ!éšîҰěýŮ6$Ť6â(*ôíčŮ€Źdüđű›ŽPQł6Ňůď9+íŚŢ §0ưźćŃŠ`ŻřßSž{Ř?ĽAŞ0-cqż¦íµâĄŤ}¸ú®â7Ń˝mb>R»kĺ·Gę-Jy»ˇn9$·ű¸;ÖqłVc'Íîu뉹wřŔ÷•5hM #ŠSuü<[ěw/pF«ĹŔ‘łA?ZŽląH“%«˛Ý‘řLď3©|űbąY,®Ďôaţ€­ĺ{J‡N„Tˇő†Ě›7ÎKÂÓŰ… DŰbo9Ç™e©ăý¦>)6={>.oAw´ţŤSV&Űsů`câ`ˇp*ś*i^˝W”¬Ĺiô”5·a@‚f©9ď ż×3y)˘Źő®voţd/‹M)ůć)Ĺ–‡żŰý.=8Ś …¤Ą”(±Ă–ŤÓaŁx*Ő…kŠęWĂĄÔX#27ĂvĚT˛×Ď˝[šeŹÝůŇW/žłĘť–Ă_s!’NA–~ĹßÖ …¸+ YĂť‚b€8™ŤŹ•¤¬C¶Apwű}SĄÍ9¬”š'5'@(íÇĽ$#ćř«Éw«k)WšuČŹ›•km^s}ŃrëúĂ&B..$ ý;żP̡řűâĚ•ňóďC˛ŚÓ4G†§±×1ŕ¶ :JěCID˝ŘgŻ¬Ôťv˙Áoǵór@ŃKą<‡şG׫XÂ[ÎËC~ ľŃ “bwÚOÁkŻÜÓŐ3m}<S䱏hrÖ««V±«'á‘{ĺ‹n·`ë{ź߀€Ěu—|:ż8I81aYUe€›@Oě˛/>aŰĂç 柏ńżç2zGä»~Ö-r±JĺmryŢ+Wţ¬ůÔP”-&wݔëŽt삌k’Ôçč.ůcLÜ}ş9–ţ#Ü5ďiź;j®W‹Ä.şi×ě‘ßÇ(ÜÓ¦Üő{Ýî„R”pÖ±.’đLѧ©@Qŕ ÇcJŘQFs©˛9–îȸű@««ąÉ¤–kSň$˘E>ޤvS#řňč©@ńę릮ž<đČzAŔ0#ľ9ËPŘśTş“¦„`»×}ż… ů€Äě›_ÚČ;xaAůfd©Ż”ě=±ayVÍý„ËöŚĹŢŻű®Ů|ňß$VÇ:ăaĘ/r0×Y}€ÖH:9bfűŤie1Ţ"šţšôĚ|ÖŔµ˛HŇgD/O ÖużÓhÄÂăůFŮ­JM8c\Ëgĺ¨ęjíDě%bKý˛yq÷üüsúX˙aÔ|J;ë÷(EféËÓ:Šß˛µ‹ (1řpĄ·źiÚş^ďWMĄNď±{đßż7Âłŕ;7îS„ Fë —qq‡×ŤĽôŠJ©ż8ŠĺŁŁhŕUn< Pń%ą>â(ĐRĎ:Z»żDJmZ&ŢeLĎ‹9rĂxÓµć'­úşěN17GDIvN6qt]% {;úg~˝?ëčK ůb»ëkŔşCm€t.‘Ir·ŕüă/ «7$ÂřU°žt©wôłü—u<ÇK­fŇĎZÍ1uň´Ţt6SM0¦m]xŐE0ŤŚłf}Eg‰…–pßr^Ž%b8ŠŢ_1¤76źŤ=đw.¨çă™®Îętő ÷˛EÂć4™˘Ź9JÂޢ4ZŽYU™ ëqIŇťř׿ľ±Ęőôůx}žŤKŮä'żú´R4Ś÷Ó¶Ó‘ŮeŢ(;ˇKÚ>[î3‹o—Iü©ÜÜ4©¸\¶*śť{3Ťů­g6F¶„yž„“ÉńGĐbĹď1Ěą!ň¨mľGÝieá]Îk料Ţ0Pzë´rîPí˙P™v ˝¨\Nď­ÔňŻćd…0FĹM„zĺ3÷s‘ß3t솽™Ö%»čPŁ Ę~BÄSg9=ťŞ”ëmMqgµK<ÁaĽwJPűhL„ŕ^Ó_­],Q*2‹ţÂĺů%ĆűnĘĆŁXĺ}:ň•$…CŞźDaáµr¦đÄäň:şI•ú$ú«*šjźŠÄGVŔŞŚĹŬÄäM™ż›d§±ü$ܳ܍O1jěőéyTұń¬‰Ď,ĺó]QťŤ±ËK7>llOĚ4ŮWĄëÂušĹr-Ü)Ljüéžąu&Júő©Ę>×čř(ńć[“hů^Ď‚Đy‰nH13¦Oą^§(kQŇź> endobj 265 0 obj << /Type /ObjStm /N 63 /First 537 /Length 2706 /Filter /FlateDecode >> stream xÚ˝Z[s›ş~÷ŻĐc{:®„ěŮłgré%inMŇ4Éž>[¶Ů8múëĎ’X\L“ÓĚ™ÉXh}úÖU ő\ä ę ä×yGTD(ˇ20¸©ăŔ¦¤č0¨ëz8đʧ nDÁG„0Ä !>bÔwá†"ć2ć"Ć€wbBI‡Ż%rH`€şă#—qQâ"—;ÁŽ\Ř ×§ €V@Ź pOT0Ä×Gľ¸"'\=†”ś‚Š9 (Î<6pä+ČąŹ8‡ńäČ9ü` Ü/ą®ŕ†‚ąÓćxÁ‚xČSó€<ć€ď@Î|pCž “Y&BD Ďc`ČQţ+xÄľPApU0Ľ…A@ ŚPľ“„NˇÂGÂ÷”${©Š„|&Rź ź;!6Čç`őňQc\äűŽ?˘ŔĘ÷}5ĆC~Ŕa _ŔŤďŚţüs„/Wá÷iRěË|’E«"ÍFúů$\›۳ýÝÓ˝7'Ńňnť_„ÉŃx7Ť§0"ç9rÍĐÝÝôú{LŔűcA'¸$po#Ľ“OdR Aéď…«Ź2š/ĘG5ˇz7¦DŚđAĆŃd'™Ç9#|QČĺ".áëR‰3…±ł Y Wxďá}üżÇđ>ÄGřźâ3|Ž/đ%ţ‚opďđOŇ8Mŕ÷râ)–Xa™LĂ|gxÁĎÄłtťá9^ŕĹăj!áđż8ĆKśŕ$J$Nq żWxf2‰ĺ¬0w™†[É,J§řg8Çą|€<úóXMRŕb‘I‰‹ď)^ăü˙ŔŹř'ţ)łôµńŕű̦:ýőדBóůęëŮ×›vh”·…G¨đ¨’…śýŻáş ß |R‡ rľö·ňrT;7U>5îSÎ+Jšľńžă›Ű“ëËŁ¶oÎĺ|˝Í/. eBTókú…4ýBš~a[ŇÖ·ťBY3kw­Ľý¨3÷“ÎÝť˝źëü˝Â_ń5ľ†ÓHf2Źrpć])‡Nä4Šăp8ąĺý:Śź“âÉzy'ł<š'OĘöUĽÎńý:-äô.ÖcŞ3ĚÔÂ22$‡«bťLaćIšÉÁńź“'‡·źwÚI0T ľJµ”ÁŞô‰`ď?)Şvb5°+üM ŰÄwÖĘM9•kÇh +:Ť'w'Xp:ΗLŇi”ĚÁŃlYšLdŽţ¦p°° VP{ňľ´‚}€ˇkŇą´¬´ĂäŚâ¤íSd mí ťŢ:µt’/é”®rŻĚBX˝MYŔňüěZĽÁ·vŞnkeZśéo˙4:Ü}ŁąiĂöËUő MT ”lÎś˛˘Ąţ¦ŔfÔťŕŰ“âÂÜ»ˇÜ¬“Ůuţϱ}Žež—ÝjžÉ’D‡¶JxöG*@°&©Á–h äÓ*BPg*@( ř. '˙ĘB€V=+ŃCč†MmZ8Ť©Ă!äćIă?1e%ä‘jo‹śĘňBµ{8JŚđQX>Ŕˇk„żFÓb\\ł«©C®a˝KÜŻŁ›ăó› ŕuś&éQ±ť™×fĆÄVfô%]_ßîî–Ě€—Z€ă0ëˇćw¨ą j|C c/@íćëއS‹šYŔ»Ě<çĚ,§± çÁŃţŐ»Ł7 ęz÷rK4ÝŽË8µ‰©m{M§CL<źŘ§/źŢ]ť˝9‹•cĽ÷± éř’ډÓă>Úfé2‹Ąk‘dîó)]ěîśZľ:O—aŇ“_ť(Ú5 =Áň•űľÚ?˙řáâ˝El[~ń®ĽF=ËCţKPŰz¦o‡®ÓČůĹËgĽCĚy>±Ám›ś$§N°59ňä¶)ŰÄ‚!bÍLc/AlđÓ"'H§™ŰÜĆ^ÄmżłŘÔÔCͬë7ÚevÎe®t < ÎÔŽ¨Đµö§hŞvU c\}s5+3d97WÖoS°mS_ë"ęlJĹŻ°‚Z—]ő ´«sş.bŘ•ĺĄ×PYĘięÓ¨~0€¤VŚ`kŚü2¶;H”éZRŻ•łL>¨Ż˘¶Wµ¦đkMŢĐ,MÁz4ÝZ“h–´OäŹB}ÖíÂÔÔ˝`;Lµ 30=lĽÚŽňËR ăZ0žŰŁÉkM6 I,^ŹŐÂ0ÎvŞ* LT0ĽßŁŮI^ŰÁYŻ#Ťďě…ł¦Ł3¬jÁ&ĂĆn ľ¶Ź;˝)¦áý&ĽkÁ‹Ax·¶ŰMxŢ@$[KbL[^Ťč6íş¦Ż«‡±UeUDŇ@dA‘Ű|Ń©«­@…č5©ŤH‡Ë „BlZÍVWŚ5bő°±¶š5­¦ «+ĆŃD¬­¦M«iĂjf[Í­¦µŐ´ŮĹ(ł©m5´šÖÝŤ6»md8µ­¦VӺёfŁ#˘ČlD6„HęžGšV“¦ŐŽŤč "ÖV“¦Ő¤a5±&"k«›F7l&¶ÍdĐćÚäfvSŃ0™Ř&“-&«ŻĘ°$żÚO'ă‹öőŻ‘Ů$Ľ W+™LŁŻ!h¬eQ±XĘ"šĽ/•ÂITČ·{ç;'śOV+5Úë{±·wy Z¦Ú/ď˘Âs_«3§Ů ŕŁh-NťńßÚlLĂ"|[„w±TłHŘú3pG-ĄbÚ!Żď˛”ŞÉ~űm&©Q%&…Ę—‡µńĽ%o ˛¶‰ý¬ű´ű > BęíżĆĚéTÉ%§–üěôâŕ^xę…§9Dv}÷ÇdRüTQŞ^ĄË=Opłk{5['“"J“|&Óqş’Y¨ŐÚkŕ†ĺvĺŽ}ŃrË%äµ0Ngăb!Ç…\®Ň,ŚÇjk®¦$e€Łdµ. čşP·ł4[†…2¦t€ŠŢtmć1ă]ńŔ‹€m^Da¬Ć¶Df\ÇاQ¶Q:V«wć[¦šÖŰLk„fbw#.Ó±ĘäJ¤Ç‰’ő váo•Ŕq-UtL°çŻĆuHj9Sńv,@•„fďP 8¸°*ë±BYc |UBN›T5_5¦źNöj:™éř']çĺ4?u¶j&-/9çRgć´«Ľ– ĽU%L-F\ôr*ö°ß\ŢŻŐđń\&˛ÎHîT­˛*ůçëĺ2Ě•EeNë†ńv®ÔPŞr 9Y$Ń’l*‹0ŠLŔ«wíâm+z ¶;féĚű™&´L¶u.Çߡ»Śu‡›e0V—iŁMó˛·<Ę0/á˝(Ç<Ş—ť•Áž¨O§ffśÔÓ5Ç;ý)ć*ĘkyÁĐÔÎľÜěŔő?®+ÝšO ZžÝŐźl¨ íËĆ«?ţw>ěĎăt>2óÍ™ľ:so¶&¤ę˙kĘĆ\§S‰żärs@?…ÂŽÎrä×+ţ Ą¤ endstream endobj 289 0 obj << /Type /XRef /Index [0 290] /Size 290 /W [1 3 1] /Root 287 0 R /Info 288 0 R /ID [<43D82A0577CA9670522F7DEDD28BBE82> <43D82A0577CA9670522F7DEDD28BBE82>] /Length 662 /Filter /FlateDecode >> stream xÚ%”ąRQEďéÇ“QDPTDdžAE@&Q™s##530µĘŔx'–`¨©ˇ‰ţef˘¬m˛jďîÇíŰ÷¬&Ą”ţf)i<K'ȧH“i:KQÜE Qo‘r €ÚIĘS`žk¤BPD˝I*%Ô¤RPFm'ťg¨m¤rPAm%U‚*°Áµë¤ł šÚB:j¨×Hµŕ<µ™tÔQŻ’.‚zj©4RŻ.ËśF9×Hyßh˘ú®Wi¦6’üČŞ—ňţZ©ő$żQ;ŐĎőës$ęŕZŐÖIőN}Ä>önĐzAč` a0FÁŕ6¸î‚Ip,DJĺžô÷´|ěE(Ŕ É#+ˇŢłTOkŽT …X^3€WĐ4ŕ/4f÷‚uů°©ę­÷b ˛”µx–ÁS°©ţ—·'`l}°©íŤ· vŔ.؇쀻* DqEteŔŽ‘z"űđĘwq\EźĹA•Uň‘ć—ü»2Ŕîuň2Ő¤yŔ,…ĎÂbˇ…PEč#”šÉ˘žđT¸ˇĘHkżý ŻçĂ®(/+B~a§řH„â‹NŠ/O8$ś^©.ŇÁg/oEůş…Žębeo …Cšř'üţ ˙„B=ˇžPO ` Ňs §qÖăěĺIű`™´–©üCŃ ‰#ZŚ[Ś[Ś[Ś[-´ ¶"˝řîĺ·#˝÷ôµéÇ˙áíFä:íEě68íG|űętŮdµÓadď’ÓQdźŽŰH‘[|™";sŤČţś‰Č-Śś as.nanoduration("10:03:02.999_999_998") ##' as.nanoduration("10:03:02.999_999_998") < "10:03:02.999_999_999" ##' ##' @seealso ##' \code{\link{nanotime}} ##' ##' @aliases *,ANY,nanoduration-method ##' @aliases *,nanoduration,ANY-method ##' @aliases *,nanoduration,nanoduration-method ##' @aliases +,ANY,nanoduration-method ##' @aliases /,ANY,nanoduration-method ##' @aliases /,nanoduration,ANY-method ##' @aliases Complex,nanoduration-method ##' @aliases Logic,ANY,nanoduration-method ##' @aliases Logic,nanoduration,ANY-method ##' @aliases Logic,nanoduration,nanoduration-method ##' @aliases Math2,nanoduration-method ##' @aliases Math,nanoduration-method ##' @aliases Summary,nanoduration-method ##' ##' @rdname nanoduration nanoduration <- function(hours = 0L, minutes = 0L, seconds = 0L, nanoseconds = 0L) { if (nargs()==0) { as.nanoduration(NULL) } else { make_duration_impl(as.integer64(hours), as.integer64(minutes), as.integer64(seconds), as.integer64(nanoseconds)) } } setOldClass("difftime") ##' @noRd setGeneric("as.nanoduration", function(x) standardGeneric("as.nanoduration")) ##' @rdname nanoduration ##' @aliases as.nanoduration setMethod("as.nanoduration", "character", function(x) { duration_from_string_impl(x) }) setAs("character", "nanoduration", function(from) as.nanoduration(from)) ##' @rdname nanoduration setMethod("as.nanoduration", "integer64", function(x) { new("nanoduration", x) }) setAs("integer64", "nanoduration", function(from) as.nanoduration(from)) ##' @rdname nanoduration setMethod("as.nanoduration", "numeric", function(x) { nm <- names(x) res <- new("nanoduration", as.integer64(x)) if (!is.null(nm)) { names(res) <- nm } res }) setAs("numeric", "nanoduration", function(from) as.nanoduration(from)) ##' @rdname nanoduration setMethod("as.nanoduration", "integer", function(x) { nm <- names(x) res <- new("nanoduration", as.integer64(x)) if (!is.null(nm)) { names(res) <- nm } res }) setAs("integer", "nanoduration", function(from) as.nanoduration(from)) ##' @rdname nanoduration setMethod("as.nanoduration", "difftime", function(x) { x <- as.numeric(x, units = "secs") s <- as.integer(x) # seconds n <- as.integer(1e9 * (x - s)) # nanoseconds nanoduration(seconds = s, nanoseconds = n) }) setAs("difftime", "nanoduration", function(from) as.nanoduration(from)) ##' @rdname nanoduration setMethod("as.nanoduration", "NULL", function(x) { new("nanoduration", as.integer64(NULL)) }) ##' @rdname nanoduration setMethod("as.nanoduration", "missing", function(x) { new("nanoduration", integer64()) }) ##' @rdname nanoduration setMethod("show", signature("nanoduration"), function(object) print(object)) ##' @rdname nanoduration setMethod("print", "nanoduration", function(x, quote=FALSE, ...) { if (length(x) == 0) { print("nanoduration(0)", quote=quote) } else { print(duration_to_string_impl(x), quote=quote) } }) ##' @rdname nanoduration format.nanoduration <- function(x, ...) { as.character(x) } ##' @rdname nanoduration ##' @method as.integer64 nanoduration as.integer64.nanoduration <- function(x, ...) { S3Part(x, strictS3=TRUE) } ##' @rdname nanoduration setMethod("as.character", signature("nanoduration"), function(x) { duration_to_string_impl(x) }) ##' @rdname nanoduration setMethod("is.na", "nanoduration", function(x) { duration_is_na_impl(x) }) ## ------------ `-` ## nanoduration - other ##' @rdname nanoduration setMethod("-", c("nanoduration", "nanoduration"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) - S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("-", c("nanoduration", "integer64"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) - e2) }) ##' @rdname nanoduration setMethod("-", c("nanoduration", "integer"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) - e2) }) ##' @rdname nanoduration setMethod("-", c("nanoduration", "numeric"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) - e2) }) ##' @rdname nanoduration setMethod("-", c("nanoduration", "difftime"), function(e1, e2) { e1 - as.nanoduration(e2) }) ##' @rdname nanoduration setMethod("-", c("nanoduration", "ANY"), function(e1, e2) { if (missing(e2)) { new("nanoduration", -S3Part(e1, strictS3=TRUE)) } else { stop("invalid operand types") } }) ## other - nanoduration ##' @rdname nanoduration setMethod("-", c("nanotime", "nanoduration"), function(e1, e2) { new("nanotime", S3Part(e1, strictS3=TRUE) - e2) }) ##' @rdname nanoduration setMethod("-", c("nanotime", "difftime"), function(e1, e2) { e1 - as.nanoduration(e2) }) ##' @rdname nanoduration setMethod("-", c("integer64", "nanoduration"), function(e1, e2) { new("nanoduration", e1 - S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("-", c("integer", "nanoduration"), function(e1, e2) { new("nanoduration", e1 - S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("-", c("numeric", "nanoduration"), function(e1, e2) { new("nanoduration", e1 - S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("-", c("difftime", "nanoduration"), function(e1, e2) { as.nanoduration(e1) - e2 }) ##' @rdname nanoduration setMethod("-", c("ANY", "nanoduration"), function(e1, e2) { stop("invalid operand types") }) ## ----------- `+` ##' @rdname nanoduration setMethod("+", c("nanoduration", "ANY"), function(e1, e2) { if (missing(e2)) { e1 } else { stop("invalid operand types") } }) ##' @rdname nanoduration setMethod("+", c("nanoduration", "nanoduration"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) + e2) }) ##' @rdname nanoduration setMethod("+", c("nanoduration", "integer64"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) + e2) }) ##' @rdname nanoduration setMethod("+", c("nanoduration", "numeric"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) + e2) }) ##' @rdname nanoduration setMethod("+", c("nanoduration", "difftime"), function(e1, e2) { e1 + as.nanoduration(e2) }) ##' @rdname nanoduration setMethod("+", c("nanotime", "nanoduration"), function(e1, e2) { new("nanotime", S3Part(e1, strictS3=TRUE) + S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("+", c("nanotime", "difftime"), function(e1, e2) { e1 + as.nanoduration(e2) }) ##' @rdname nanoduration setMethod("+", c("nanoduration", "nanotime"), function(e1, e2) { new("nanotime", S3Part(e1, strictS3=TRUE) + S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("+", c("difftime", "nanotime"), function(e1, e2) { as.nanoduration(e1) + e2 }) ##' @rdname nanoduration setMethod("+", c("nanoival", "nanoduration"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e1, e2)) }) ##' @rdname nanoduration setMethod("-", c("nanoival", "nanoduration"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e1, -e2)) }) ##' @rdname nanoduration setMethod("+", c("nanoduration", "nanoival"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e2, e1)) }) ##' @rdname nanoduration setMethod("+", c("nanoival", "difftime"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e1, as.nanoduration(e2))) }) ##' @rdname nanoduration setMethod("-", c("nanoival", "difftime"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e1, -as.nanoduration(e2))) }) ##' @rdname nanoduration setMethod("+", c("difftime", "nanoival"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e2, as.nanoduration(e1))) }) ##' @noRd setMethod("+", c("ANY", "nanoduration"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoduration setMethod("+", c("integer64", "nanoduration"), function(e1, e2) { new("nanoduration", e1 + S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("+", c("numeric", "nanoduration"), function(e1, e2) { new("nanoduration", e1 + S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("+", c("difftime", "nanoduration"), function(e1, e2) { as.nanoduration(e1) + e2 }) ## ----------- `*` ##' @noRd setMethod("*", c("nanoduration", "nanoduration"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoduration setMethod("*", c("nanoduration", "numeric"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) * e2) }) ##' @rdname nanoduration setMethod("*", c("nanoduration", "integer64"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) * e2) }) ##' @rdname nanoduration setMethod("*", c("numeric", "nanoduration"), function(e1, e2) { new("nanoduration", e1 * S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("*", c("integer64", "nanoduration"), function(e1, e2) { new("nanoduration", e1 * S3Part(e2, strictS3=TRUE)) }) ##' @noRd setMethod("*", c("nanoduration", "ANY"), function(e1, e2) { stop("invalid operand types") }) ##' @noRd setMethod("*", c("ANY", "nanoduration"), function(e1, e2) { stop("invalid operand types") }) ## ----------- `/` ##' @rdname nanoduration setMethod("/", c("nanoduration", "nanoduration"), function(e1, e2) { as.integer64(S3Part(e1, strictS3=TRUE) / S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoduration setMethod("/", c("nanoduration", "integer64"), function(e1, e2) { new("nanoduration", as.integer64(S3Part(e1, strictS3=TRUE) / e2)) }) ##' @rdname nanoduration setMethod("/", c("nanoduration", "numeric"), function(e1, e2) { new("nanoduration", as.integer64(S3Part(e1, strictS3=TRUE) / e2)) }) ##' @noRd setMethod("/", c("nanoduration", "ANY"), function(e1, e2) { stop("invalid operand types") }) ##' @noRd setMethod("/", c("ANY", "nanoduration"), function(e1, e2) { stop("invalid operand types") }) ## ---------- other ops ##' @rdname nanoduration setMethod("Arith", c("nanoduration", "ANY"), function(e1, e2) { callNextMethod(S3Part(e1, strictS3=TRUE), e2) }) ##' @rdname nanoduration setMethod("Compare", c("nanoduration", "character"), function(e1, e2) { ne2 <- as.nanoduration(e2) callNextMethod(e1, ne2) }) ##' @rdname nanoduration setMethod("Compare", c("character", "nanoduration"), function(e1, e2) { ne1 <- as.nanoduration(e1) callNextMethod(ne1, e2) }) ##' @rdname nanoduration setMethod("Compare", c("nanoduration", "ANY"), function(e1, e2) { callNextMethod(S3Part(e1, strictS3=TRUE), e2) }) ##' @noRd setMethod("Logic", c("nanoduration", "nanoduration"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @noRd setMethod("Logic", c("nanoduration", "ANY"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @noRd setMethod("Logic", c("ANY", "nanoduration"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @rdname nanoduration setMethod("abs", c("nanoduration"), function(x) { new("nanoduration", callNextMethod(S3Part(x, strictS3=TRUE))) }) ##' @rdname nanoduration setMethod("sign", c("nanoduration"), function(x) { callNextMethod(S3Part(x, strictS3=TRUE)) }) ##' @noRd setMethod("Math", c("nanoduration"), function(x) { ## this is the same error message that R gives for abs("A") stop("non-numeric argument to mathematical function") }) ##' @noRd setMethod("Math2", c("nanoduration"), function(x, digits) { ## this is the same error message that R gives for round("A") stop("non-numeric argument to mathematical function") }) ##' @noRd setMethod("Summary", c("nanoduration"), function(x, ..., na.rm = FALSE) { ## this is the same error message that R gives for sum("A") stop("invalid 'type' (nanoduration) of argument") }) ##' @rdname nanoduration setMethod("sum", c("nanoduration"), function(x, ..., na.rm = FALSE) { new("nanoduration", callNextMethod()) }) ##' @rdname nanoduration setMethod("min", c("nanoduration"), function(x, ..., na.rm = FALSE) { new("nanoduration", callNextMethod()) }) ##' @rdname nanoduration setMethod("max", c("nanoduration"), function(x, ..., na.rm = FALSE) { new("nanoduration", callNextMethod()) }) ##' @rdname nanoduration setMethod("range", c("nanoduration"), function(x, ..., na.rm = FALSE) { new("nanoduration", callNextMethod()) }) ##' @noRd setMethod("Complex", c("nanoduration"), function(z) { ## this is the same error message that R gives for Arg("A") stop("non-numeric argument to function") }) ## non-ops: ## ------- ## subset/subassign ##' @rdname nanoduration setMethod("[[", signature("nanoduration"), function (x, i, j, ..., drop=FALSE) { new("nanoduration", callNextMethod()) }) ##' @rdname nanoduration setMethod("[", signature("nanoduration", "numeric"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoduration' subsetting") } if (isTRUE(any(i < 0))) { new("nanoduration", S3Part(x, strictS3=TRUE)[i]) } else { nanoduration_subset_numeric_impl(x, i) } }) ##' @rdname nanoduration setMethod("[", signature("nanoduration", "logical"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoduration' subsetting") } nanoduration_subset_logical_impl(x, i) }) ##' @rdname nanoduration setMethod("[", signature("nanoduration", "character"), function (x, i, j, ..., drop=FALSE) { ## we don't implement 'period_subset_character_impl' but ## do the gymnastic of finding the NAs here at R level; ## it's not as efficient, but using 'character' indexing ## is by itself inefficient, so the overhead should have ## no practical consequences. if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoduration' subsetting") } na_index <- !(i %in% names(x)) | is.na(i) res <- new("nanoduration", S3Part(x, strictS3=TRUE)[i]) res[na_index] <- NA_nanoduration_ res }) ##' @rdname nanoduration setMethod("[", signature("nanoduration", "ANY"), function (x, i, j, ..., drop=FALSE) { stop("']' not defined on 'nanoduration' for index of type 'ANY'") }) ##' @rdname nanoduration setMethod("[<-", signature("nanoduration"), function (x, i, j, ..., value) { new("nanoduration", callNextMethod()) }) ##' @rdname nanoduration c.nanoduration <- function(...) { as.nanoduration(c.integer64(...)) } ##' @rdname nanotime as.data.frame.nanoduration <- function(x, ...) { ret <- as.data.frame(S3Part(x, strictS3=TRUE), ...) ## this works, but see if there's a more idiomatic and efficient way ## of doing this: ret[] <- as.nanoduration(S3Part(x, strictS3=TRUE)) ret } ##' Sequence Generation ##' ##' Generate a sequence of \code{nanoduration} ##' ##' @param ... arguments passed to or from methods ##' @param from,to the starting and (maximal) end values of the ##' sequence ##' @param by the increment of the sequence ##' @param length.out integer indicating the desired length of the sequence ##' @param along.with take the length from the length of this argument. ##' ##' @examples ##' seq(from=as.nanoduration(0), by=as.nanoduration("01:00:00"), length.out=10) ##' @method seq nanoduration seq.nanoduration <- function(from, to=NULL, by=NULL, length.out=NULL, along.with=NULL, ...) { ## workaroud 'bit64' bug: if (is.null(by)) { if (is.null(length.out)) { length.out <- length(along.with) } by = (to - from) / (length.out - 1) } as.nanoduration(seq(as.integer64(from), to, as.integer64(by), length.out, along.with, ...)) } ##' Test if Two Objects are (Nearly) Equal ##' ##' Compare \code{target} and \code{current} testing \sQuote{near ##' equality}. If they are different, comparison is still made to ##' some extent, and a report of the differences is returned. Do not ##' use \code{all.equal} directly in \code{if} expressions---either ##' use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if ##' appropriate. ##' ##' @param target,current \code{nanoduration} arguments to be compared ##' @param ... further arguments for different methods ##' @param tolerance numeric >= 0. Differences smaller than ##' \code{tolerance} are not reported. The default value is close ##' to \code{1.5e-8}. ##' @param scale \code{NULL} or numeric > 0, typically of length 1 or ##' \code{length(target)}. See \sQuote{Details}. ##' @param countEQ logical indicating if the \code{target == current} cases should be ##' counted when computing the mean (absolute or relative) ##' differences. The default, \code{FALSE} may seem misleading in ##' cases where \code{target} and \code{current} only differ in a few ##' places; see the extensive example. ##' @param formatFUN a \code{function} of two arguments, \code{err}, the relative, absolute ##' or scaled error, and \code{what}, a character string indicating ##' the _kind_ of error; maybe used, e.g., to format relative and ##' absolute errors differently. ##' @param check.attributes logical indicating if the \code{attributes} of \code{target} ##' and \code{current} (other than the names) should be compared. ##' ##' @seealso \code{\link{identical}}, \code{\link{isTRUE}}, ##' \code{\link{==}}, and \code{\link{all}} for exact equality ##' testing. ##' ##' @method all.equal nanoduration ##' all.equal.nanoduration <- function(target, current, tolerance = sqrt(.Machine$double.eps), scale = NULL, countEQ = FALSE, formatFUN = function(err, what) format(err), ..., check.attributes = TRUE) { ## a bit of a kludge, but both 'nanoduration' and 'nanotime' are ## based on 'integer64'; because of a bug in 'all.equal.integer64' ## we have to redefine 'all.equal.nanotime' and it is correct for ## all 'integer64'-based S4 classes; in theory they would all ## three be the same function: if (inherits(target, "nanoduration")) target <- as.nanotime(target) if (inherits(current, "nanoduration")) current <- as.nanotime(current) all.equal.nanotime(target, current, tolerance, scale, countEQ, formatFUN, ..., check.attributes=check.attributes) } ##' @rdname all.equal.nanoduration setMethod("all.equal", c(target = "nanoduration", current="ANY"), all.equal.nanoduration) ##' @rdname nanoduration NA_nanoduration_ <- as.nanoduration(NA_integer_) ## rounding ops: ##' @rdname rounding setMethod("nano_ceiling", c(x="nanotime", precision="nanoduration"), function(x, precision, origin=nanotime()) { if (!inherits(origin, "nanotime")) { stop("'origin' must be of class 'nanotime'") } ceiling_impl(x, precision, origin) }) ##' @rdname rounding setMethod("nano_floor", c(x="nanotime", precision="nanoduration"), function(x, precision, origin=nanotime()) { if (!inherits(origin, "nanotime")) { stop("'origin' must be of class 'nanotime'") } floor_impl(x, precision, origin) }) ##' Replicate Elements ##' ##' Replicates the values in 'x' similarly to the default method. ##' ##' @param x a vector of \code{nanoduration} ##' @param ... further arguments: ##' ##' 'times' an integer-valued vector giving the (non-negative) ##' number of times to repeat each element if of length ##' 'length(x)', or to repeat the whole vector if of length ##' 1. Negative or 'NA' values are an error. A 'double' ##' vector is accepted, other inputs being coerced to an ##' integer or double vector. ##' ##' 'length.out' non-negative integer. The desired length of the ##' output vector. Other inputs will be coerced to a double ##' vector and the first element taken. Ignored if 'NA' or ##' invalid. ##' ##' 'each' non-negative integer. Each element of 'x' is repeated ##' 'each' times. Other inputs will be coerced to an integer ##' or double vector and the first element taken. Treated as ##' '1' if 'NA' or invalid. setMethod("rep", c(x = "nanoduration"), function(x, ...) { new("nanoduration", callNextMethod()) }) nanotime/R/RcppExports.R0000644000176200001440000002044114130027346014702 0ustar liggesusers# Generated by using Rcpp::compileAttributes() -> do not edit by hand # Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 duration_from_string_impl <- function(str) { .Call(`_nanotime_duration_from_string_impl`, str) } duration_to_string_impl <- function(dur) { .Call(`_nanotime_duration_to_string_impl`, dur) } duration_is_na_impl <- function(dur) { .Call(`_nanotime_duration_is_na_impl`, dur) } make_duration_impl <- function(h_nv, m_nv, s_nv, n_nv) { .Call(`_nanotime_make_duration_impl`, h_nv, m_nv, s_nv, n_nv) } nanoduration_subset_numeric_impl <- function(v, idx) { .Call(`_nanotime_nanoduration_subset_numeric_impl`, v, idx) } nanoduration_subset_logical_impl <- function(v, idx_p) { .Call(`_nanotime_nanoduration_subset_logical_impl`, v, idx_p) } nanoival_intersect_idx_time_interval_impl <- function(nv1, nv2) { .Call(`_nanotime_nanoival_intersect_idx_time_interval_impl`, nv1, nv2) } nanoival_intersect_idx_time_interval_logical_impl <- function(nv1, nv2) { .Call(`_nanotime_nanoival_intersect_idx_time_interval_logical_impl`, nv1, nv2) } nanoival_intersect_time_interval_impl <- function(nv1, nv2) { .Call(`_nanotime_nanoival_intersect_time_interval_impl`, nv1, nv2) } nanoival_setdiff_time_interval_impl <- function(nv1, nv2) { .Call(`_nanotime_nanoival_setdiff_time_interval_impl`, nv1, nv2) } nanoival_union_impl <- function(nv1, nv2) { .Call(`_nanotime_nanoival_union_impl`, nv1, nv2) } nanoival_intersect_impl <- function(nv1, nv2) { .Call(`_nanotime_nanoival_intersect_impl`, nv1, nv2) } nanoival_setdiff_impl <- function(nv1, nv2) { .Call(`_nanotime_nanoival_setdiff_impl`, nv1, nv2) } nanoival_is_unsorted_impl <- function(nvec, strictlyvec) { .Call(`_nanotime_nanoival_is_unsorted_impl`, nvec, strictlyvec) } nanoival_sort_impl <- function(nvec, decreasingvec) { .Call(`_nanotime_nanoival_sort_impl`, nvec, decreasingvec) } nanoival_sort_impl2 <- function(nvec, decreasing) { .Call(`_nanotime_nanoival_sort_impl2`, nvec, decreasing) } nanoival_lt_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_lt_impl`, n1, n2) } nanoival_le_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_le_impl`, n1, n2) } nanoival_gt_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_gt_impl`, n1, n2) } nanoival_ge_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_ge_impl`, n1, n2) } nanoival_eq_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_eq_impl`, n1, n2) } nanoival_ne_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_ne_impl`, n1, n2) } nanoival_plus_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_plus_impl`, n1, n2) } nanoival_minus_impl <- function(n1, n2) { .Call(`_nanotime_nanoival_minus_impl`, n1, n2) } nanoival_setdiff_idx_time_interval_impl <- function(nv1, cv2) { .Call(`_nanotime_nanoival_setdiff_idx_time_interval_impl`, nv1, cv2) } nanoival_new_impl <- function(sv, ev, sopenv, eopenv) { .Call(`_nanotime_nanoival_new_impl`, sv, ev, sopenv, eopenv) } nanoival_get_start_impl <- function(cv) { .Call(`_nanotime_nanoival_get_start_impl`, cv) } nanoival_get_end_impl <- function(cv) { .Call(`_nanotime_nanoival_get_end_impl`, cv) } nanoival_get_sopen_impl <- function(cv) { .Call(`_nanotime_nanoival_get_sopen_impl`, cv) } nanoival_get_eopen_impl <- function(cv) { .Call(`_nanotime_nanoival_get_eopen_impl`, cv) } nanoival_isna_impl <- function(cv) { .Call(`_nanotime_nanoival_isna_impl`, cv) } nanoival_make_impl <- function(nt_v, tz_v) { .Call(`_nanotime_nanoival_make_impl`, nt_v, tz_v) } nanoival_subset_numeric_impl <- function(v, idx) { .Call(`_nanotime_nanoival_subset_numeric_impl`, v, idx) } nanoival_subset_logical_impl <- function(v, idx_p) { .Call(`_nanotime_nanoival_subset_logical_impl`, v, idx_p) } nanotime_wday_impl <- function(tm_v, tz_v) { .Call(`_nanotime_nanotime_wday_impl`, tm_v, tz_v) } nanotime_mday_impl <- function(tm_v, tz_v) { .Call(`_nanotime_nanotime_mday_impl`, tm_v, tz_v) } nanotime_month_impl <- function(tm_v, tz_v) { .Call(`_nanotime_nanotime_month_impl`, tm_v, tz_v) } nanotime_year_impl <- function(tm_v, tz_v) { .Call(`_nanotime_nanotime_year_impl`, tm_v, tz_v) } nanotime_make_impl <- function(nt_v, tz_v) { .Call(`_nanotime_nanotime_make_impl`, nt_v, tz_v) } nanotime_subset_numeric_impl <- function(v, idx) { .Call(`_nanotime_nanotime_subset_numeric_impl`, v, idx) } nanotime_subset_logical_impl <- function(v, idx_p) { .Call(`_nanotime_nanotime_subset_logical_impl`, v, idx_p) } period_from_string_impl <- function(str) { .Call(`_nanotime_period_from_string_impl`, str) } period_from_parts_impl <- function(months_v, days_v, dur_v) { .Call(`_nanotime_period_from_parts_impl`, months_v, days_v, dur_v) } period_to_string_impl <- function(prd) { .Call(`_nanotime_period_to_string_impl`, prd) } period_from_integer64_impl <- function(i64) { .Call(`_nanotime_period_from_integer64_impl`, i64) } period_from_integer_impl <- function(iint) { .Call(`_nanotime_period_from_integer_impl`, iint) } period_from_double_impl <- function(dbl) { .Call(`_nanotime_period_from_double_impl`, dbl) } plus_period_period_impl <- function(e1_nv, e2_nv) { .Call(`_nanotime_plus_period_period_impl`, e1_nv, e2_nv) } minus_period_impl <- function(e1_cv) { .Call(`_nanotime_minus_period_impl`, e1_cv) } minus_period_period_impl <- function(e1_cv, e2_cv) { .Call(`_nanotime_minus_period_period_impl`, e1_cv, e2_cv) } eq_period_period_impl <- function(e1_p, e2_p) { .Call(`_nanotime_eq_period_period_impl`, e1_p, e2_p) } ne_period_period_impl <- function(e1_p, e2_p) { .Call(`_nanotime_ne_period_period_impl`, e1_p, e2_p) } plus_period_integer64_impl <- function(e1_cv, e2_nv) { .Call(`_nanotime_plus_period_integer64_impl`, e1_cv, e2_nv) } minus_period_integer64_impl <- function(e1_cv, e2_nv) { .Call(`_nanotime_minus_period_integer64_impl`, e1_cv, e2_nv) } multiplies_period_integer64_impl <- function(e1_cv, e2_nv) { .Call(`_nanotime_multiplies_period_integer64_impl`, e1_cv, e2_nv) } divides_period_integer64_impl <- function(e1_cv, e2_nv) { .Call(`_nanotime_divides_period_integer64_impl`, e1_cv, e2_nv) } multiplies_period_double_impl <- function(e1_cv, e2_nv) { .Call(`_nanotime_multiplies_period_double_impl`, e1_cv, e2_nv) } divides_period_double_impl <- function(e1_cv, e2_nv) { .Call(`_nanotime_divides_period_double_impl`, e1_cv, e2_nv) } minus_integer64_period_impl <- function(e1_nv, e2_cv) { .Call(`_nanotime_minus_integer64_period_impl`, e1_nv, e2_cv) } plus_nanotime_period_impl <- function(e1_nv, e2_cv, tz_v) { .Call(`_nanotime_plus_nanotime_period_impl`, e1_nv, e2_cv, tz_v) } minus_nanotime_period_impl <- function(e1_nv, e2_cv, tz_v) { .Call(`_nanotime_minus_nanotime_period_impl`, e1_nv, e2_cv, tz_v) } plus_nanoival_period_impl <- function(e1_cv, e2_cv, tz_v) { .Call(`_nanotime_plus_nanoival_period_impl`, e1_cv, e2_cv, tz_v) } minus_nanoival_period_impl <- function(e1_cv, e2_cv, tz_v) { .Call(`_nanotime_minus_nanoival_period_impl`, e1_cv, e2_cv, tz_v) } period_month_impl <- function(e_n) { .Call(`_nanotime_period_month_impl`, e_n) } period_day_impl <- function(e_n) { .Call(`_nanotime_period_day_impl`, e_n) } period_duration_impl <- function(e_n) { .Call(`_nanotime_period_duration_impl`, e_n) } period_isna_impl <- function(cv) { .Call(`_nanotime_period_isna_impl`, cv) } period_seq_from_to_impl <- function(from_nv, to_nv, by_cv, tz) { .Call(`_nanotime_period_seq_from_to_impl`, from_nv, to_nv, by_cv, tz) } period_seq_from_length_impl <- function(from_nv, by_cv, n_nv, tz) { .Call(`_nanotime_period_seq_from_length_impl`, from_nv, by_cv, n_nv, tz) } period_subset_numeric_impl <- function(v, idx) { .Call(`_nanotime_period_subset_numeric_impl`, v, idx) } period_subset_logical_impl <- function(v, idx_p) { .Call(`_nanotime_period_subset_logical_impl`, v, idx_p) } ceiling_tz_impl <- function(nt_v, prd_v, orig_v, tz_v) { .Call(`_nanotime_ceiling_tz_impl`, nt_v, prd_v, orig_v, tz_v) } ceiling_impl <- function(nt_v, dur_v, orig_v) { .Call(`_nanotime_ceiling_impl`, nt_v, dur_v, orig_v) } floor_tz_impl <- function(nt_v, prd_v, orig_v, tz_v) { .Call(`_nanotime_floor_tz_impl`, nt_v, prd_v, orig_v, tz_v) } floor_impl <- function(nt_v, dur_v, orig_v) { .Call(`_nanotime_floor_impl`, nt_v, dur_v, orig_v) } nanotime/R/nanotime.R0000644000176200001440000011266614322073154014237 0ustar liggesusers##' @rdname nanotime setClass("nanotime", contains = "integer64") ## setClass("nanotime", contains = "numeric") also possible if we don't want integer64 ##' Nanosecond resolution datetime functionality ##' ##' Functions to operate on nanosecond time resolution using integer64 ##' bit representation. Conversion functions for several standard R ##' types are provided, and more will be added as needed. ##' ##' Notice that the conversion from POSIXct explicitly sets the last ##' three digits to zero. Nanosecond time stored in a 64-bit integer ##' has nineteen digits precision where doubles (which are used ##' internally for POSIXct as well) only have sixteen digits. So ##' rather than showing three more (essentially \emph{random}) digits ##' it is constructed such that these three additional digits are ##' zeros. ##' ##' @section Caveats: ##' ##' Working with dates and times is \emph{difficult}. One needs a ##' representation of both \emph{time points} and \emph{time ##' duration}. In R, think of \code{Date} or \code{POSIXct} objects ##' for the former, and \code{difftime} for the later. Here we have ##' time points \code{nanotime}, an interval type \code{nanoival} and ##' two flavors of duration which are a simple count of nanoseconds ##' \code{nanoduration} and a calendar duration that is able to track ##' concepts such as months and days \code{nanoperiod}. Point in time ##' and intervals are all based on durations relative to the epoch of ##' January 1, 1970. ##' ##' @section Input and Output Format: ##' ##' Formatting and character conversion for \code{nanotime} objects is ##' done by functions from the \code{\link{RcppCCTZ}} package relying ##' on code from its embedded \code{CCTZ} library. The default format ##' is ISO3339 compliant: \code{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez}. It ##' specifies a standard ISO 8601 part for date and time --- as well ##' as nine digits of precision for fractional seconds (down to ##' nanoseconds) and on offset (typically zero as we default to UTC). ##' It can be overriden by using \code{options()} with the key of ##' \code{nanotimeFormat} and a suitable value. Similarly, ##' \code{nanotimeTz} can be used to select a different timezone. ##' ##' For input, some slack it cut, and various shortened formats are ##' accepted by default such as \code{2020-03-10} or \code{2020-03-10 ##' 18:16:00}, or \code{2020-03-10 18:16:00.001} (and the \sQuote{T} ##' separator is optional. ##' ##' @section \code{tz} parameter usage in constructors: ##' ##' The \code{tz} parameter is allowed only when constructing a ##' \code{nanotime} from a \code{character}. This is because any ##' \code{numeric}, \code{Date} and \code{POSIXct} is de facto ##' considered an offset since the epoch. On the contrary, a ##' \code{character} is considered interpretable and hence if it does ##' not contain a timezone in its representation, it is possible to ##' specify the \code{tz} argument to specify in which timezone it ##' should be interpreted. This is useful in particular if one wants ##' to convert a \code{Date} to be aligned to the beginning of the day ##' in a specific timezone; in this case one should convert the ##' \code{Date} to a \code{character} before calling the ##' \code{nanotime} constructor with the desired timezone. ##' ##' @param x,from \code{nanotime} objects ##' @param tz character specifying a timezone which is required for ##' \code{as.POSIXct}, \code{as.POSIXlt} and can be specified for ##' \code{as.nanotime}, \code{format} and \code{print}; it can ##' also be set via \code{options("nanotimeTz")} and uses ##' \sQuote{UTC} as a default and fallback ##' @param ... further arguments passed to or from methods. ##' @param e1 Operand of class \code{nanotime} ##' @param e2 Operand of class \code{nanotime} ##' @param format A character string. Can also be set via ##' \code{options("nanotimeFormat")} and uses ##' \sQuote{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez} as a default and ##' fallback ##' @param digits Required for \code{Math2} signature but ignored here ##' @param object argument for method \code{show} ##' @param na.rm a logical indicating whether missing values should be ##' removed. ##' @param i index specifying elements to extract or replace. ##' @param j Required for \code{[} signature but ignored here ##' @param drop Required for \code{[} signature but ignored here ##' @param z Required for \code{Complex} signature but ignored here ##' @param value argument for \code{nanotime-class} ##' @param quote indicates if the output of \code{print} should be ##' quoted ##' @return A nanotime object ##' @author Dirk Eddelbuettel ##' @author Leonardo Silvestri ##' @examples ##' \dontrun{ ##' x <- nanotime(1) ##' print(x) ##' as.nanotime("1970-01-01T00:00:00.000000001+00:00") ##' as.nanotime("2020-03-10 Europe/Berlin") ##' as.nanotime("2020-03-10 18:31:23.001", tz="America/New_York") ##' x <- x + 1 ##' print(x) ##' format(x) ##' x <- x + 10 ##' print(x) ##' format(x) ##' nanotime(Sys.time()) + 1:3 # three elements each 1 ns apart ##' seq(x, by=as.nanoperiod("1d"), length.out=5, tz="Asia/Tokyo") ##' } ##' @seealso \code{\link{nanoival}}, \code{\link{nanoduration}}, ##' \code{\link{nanoperiod}}, \code{\link{seq.nanotime}} nanotime <- function(from, ...) { if (missing(from)) { from = NULL } new("nanotime", as.integer64(from, keep.names=TRUE)) } ##' @noRd setGeneric("nanotime") ##' @rdname nanotime as.nanotime <- function(from, ...) { if (missing(from)) { from = NULL } new("nanotime", as.integer64(from, keep.names=TRUE)) } ##' @noRd setGeneric("as.nanotime") setAs("integer64", "nanotime", function(from) new("nanotime", as.integer64(from, keep.names=TRUE))) .getTz <- function(x, tz="") { if (tz=="") { if (!is.null(tzone <- attr(x, "tzone"))) tz <- tzone else tz <- getOption("nanotimeTz", default="UTC") } tz } .getFormat <- function(format="") { if (format=="") { format <- getOption("nanotimeFormat", default="%Y-%m-%dT%H:%M:%EXS%Ez") } format } .secondaryNanotimeParse <- function(x, format="", tz="") { if (length(x) == 0) return(character(0)) # nocov format <- gsub("%EXS", "%E9S", .getFormat(format)) tz <- .getTz(x, tz) n <- names(x) d <- RcppCCTZ::parseDouble(x, fmt=format, tzstr=tz) res <- new("nanotime", as.integer64(d[,1]) * as.integer64(1e9) + as.integer64(d[, 2])) if (!is.null(n)) { names(S3Part(res, strictS3=TRUE)) <- n } res } .nanotime_character <- function(from, format="", tz="") { tryCatch(nanotime_make_impl(from, tz), error=function(e) { if (grepl("Cannot retrieve timezone", e$message) || e$message == "timezone is specified twice: in the string and as an argument") { stop(e$message) } else { .secondaryNanotimeParse(from, format, tz) } }) } ##' @rdname nanotime setMethod("nanotime", "character", .nanotime_character) ##' @rdname nanotime setMethod("as.nanotime", "character", .nanotime_character) setAs("character", "nanotime", function(from) .nanotime_character(from)) ##' @rdname nanotime ## This does not lead to S3 dispatch, the call must be 'nanotime.matrix' nanotime.matrix <- function(x) { n <- names(x) res <- new("nanotime", as.integer64(x[,1]) * as.integer64(1e9) + as.integer64(x[, 2])) if (!is.null(n)) { names(res) <- n ## #nocov } res } .nanotime_posixct <- function(from) { ## force last three digits to be zero n <- names(from) res <- new("nanotime", as.integer64(as.numeric(from) * 1e6) * 1000) if (!is.null(n)) { names(S3Part(res, strictS3=TRUE)) <- n } res } ##' @rdname nanotime setMethod("nanotime", signature(from="POSIXct"), .nanotime_posixct) ##' @rdname nanotime setMethod("as.nanotime", signature(from="POSIXct"), .nanotime_posixct) setAs("POSIXct", "nanotime", .nanotime_posixct) ##' @rdname nanotime setMethod("nanotime", "POSIXlt", function(from) nanotime(as.POSIXct(from))) ##' @rdname nanotime setMethod("as.nanotime", "POSIXlt", function(from) nanotime(as.POSIXct(from))) setAs("POSIXlt", "nanotime", function(from) nanotime(as.POSIXct(from))) ##' @rdname nanotime setMethod("nanotime", "Date", function(from) nanotime(as.POSIXct(from))) ##' @rdname nanotime setMethod("as.nanotime", "Date", function(from) nanotime(as.POSIXct(from))) setAs("Date", "nanotime", function(from) nanotime(as.POSIXct(from))) ##' @rdname nanotime setMethod("print", "nanotime", function(x, format="", tz="", quote=FALSE, ...) { format <- .getFormat(format) tz <- .getTz(x, tz) max.print <- options()$max.print if (length(x) > max.print) { ## #nocov start f <- head(x, max.print) print(format(f, format, tz, ...), quote=quote) cat(paste(' [ reached getOption("max.print") -- omitted', length(x) - max.print, "entries ]\n")) } ## #nocov end else { print(format(x, format, tz, ...), quote=quote) } invisible(x) }) ##' @rdname nanotime setMethod("show", signature("nanotime"), function(object) print(object)) ## #nocov ##' @rdname nanotime format.nanotime <- function(x, format="", tz="", ...) { if (length(x) == 0) { "nanotime(0)" } else { format <- .getFormat(format) tz <- .getTz(x, tz) if (length(x) == 0) { return(character(0)) ## #nocov } bigint <- as.integer64(x) secs <- as.integer64(bigint / as.integer64(1000000000)) nanos <- bigint - secs * as.integer64(1000000000) nanos_notna <- nanos[!is.na(nanos)] ## EXS has special meaning for us: print with the least number of nanotime digits if (length(nanos_notna) != 0 && isTRUE(as.logical(grep("%EXS", format)))) { if (all(nanos_notna %% 1000000000 == 0)) { format <- gsub("%EXS", "%S", format) } else if (all(nanos_notna %% 1000000 == 0)) { format <- gsub("%EXS", "%E3S", format) } else if (all(nanos_notna %% 1000 == 0)) { format <- gsub("%EXS", "%E6S", format) } else { format <- gsub("%EXS", "%E9S", format) } } res <- RcppCCTZ::formatDouble(as.double(secs), as.double(nanos), fmt=format, tgttzstr=tz) res[is.na(x)] <- as.character(NA) n <- names(x) if (!is.null(n)) { names(res) <- n } res } } ##' @rdname nanotime index2char.nanotime <- function(x, ...) { bigint <- as.integer64(x) secs <- as.integer64(bigint / as.integer64(1000000000)) nanos <- bigint - secs * as.integer64(1000000000) RcppCCTZ::formatDouble(as.double(secs), as.double(nanos), fmt=getOption("nanotimeFormat", default="%Y-%m-%dT%H:%M:%E9S%Ez"), tgttzstr=getOption("nanotimeTz", default="UTC")) } ##' @rdname nanotime as.POSIXct.nanotime <- function(x, tz="", ...) { ## if (verbose) warning("Lossy conversion dropping precision") if ((tz == "" || is.null(tz)) && length(attr(x, "tzone")) > 0) { tz <- attr(x, "tzone") } pt <- as.POSIXct(as.double(S3Part(x, strictS3=TRUE)/1e9), tz=tz, origin="1970-01-01") pt } setAs("nanotime", "POSIXct", function(from) as.POSIXct.nanotime(from)) ##' @rdname nanotime as.POSIXlt.nanotime <- function(x, tz="", ...) { as.POSIXlt(as.POSIXct(x, tz=tz)) } setAs("nanotime", "POSIXlt", function(from) as.POSIXlt.nanotime(from)) ##' @rdname nanotime as.Date.nanotime <- function(x, ...) { as.Date(as.POSIXct(x)) } setAs("nanotime", "Date", function(from) as.Date(as.POSIXct(from))) ##' @rdname nanotime as.data.frame.nanotime <- function(x, ...) { ret <- as.data.frame(S3Part(x, strictS3=TRUE), ...) ## this works, but see if there's a more idiomatic and efficient way ## of doing this: ret[] <- nanotime(S3Part(x, strictS3=TRUE)) ret } ##' @rdname nanotime ##' @method as.integer64 nanotime as.integer64.nanotime <- function(x, ...) { S3Part(x, strictS3=TRUE) } setAs("nanotime", "integer64", function(from) S3Part(from, strictS3=TRUE)) ## ------------ `-` ##' @rdname nanotime setMethod("-", c("nanotime", "character"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanotime setMethod("-", c("nanotime", "nanotime"), function(e1, e2) { new("nanoduration", S3Part(e1, strictS3=TRUE) - S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanotime setMethod("-", c("nanotime", "integer64"), function(e1, e2) { new("nanotime", S3Part(e1, strictS3=TRUE) - e2) }) ##' @rdname nanotime setMethod("-", c("nanotime", "numeric"), function(e1, e2) { new("nanotime", S3Part(e1, strictS3=TRUE) - e2) }) ##' @rdname nanotime setMethod("-", c("ANY", "nanotime"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanotime setMethod("-", c("nanotime", "ANY"), function(e1, e2) { if (missing(e2)) { stop("unary '-' is not defined for \"nanotime\" objects") } else { stop("invalid operand types") ## #nocov } }) ## ----------- `+` ##' @rdname nanotime setMethod("+", c("nanotime", "ANY"), function(e1, e2) { if (missing(e2)) { stop("unary '+' is not defined for \"nanotime\" objects") ## #nocov } else { stop("invalid operand types") } }) ##' @rdname nanotime setMethod("+", c("nanotime", "integer64"), function(e1, e2) { new("nanotime", S3Part(e1, strictS3=TRUE) + e2) }) ##' @rdname nanotime setMethod("+", c("nanotime", "numeric"), function(e1, e2) { new("nanotime", S3Part(e1, strictS3=TRUE) + e2) }) ##' @rdname nanotime setMethod("+", c("ANY", "nanotime"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanotime setMethod("+", c("integer64", "nanotime"), function(e1, e2) { new("nanotime", e1 + S3Part(e2, strictS3=TRUE)) ## #nocov }) ##' @rdname nanotime setMethod("+", c("numeric", "nanotime"), function(e1, e2) { new("nanotime", e1 + S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanotime setMethod("+", c("nanotime", "nanotime"), function(e1, e2) { stop("invalid operand types") }) ## ---------- other ops ##' @rdname nanotime setMethod("Arith", c("nanotime", "nanotime"), function(e1, e2) { stop("operation not defined for \"nanotime\" objects") }) ##' @rdname nanotime setMethod("Arith", c("nanotime", "ANY"), function(e1, e2) { stop("operation not defined for \"nanotime\" objects") }) ##' @rdname nanotime setMethod("Arith", c("ANY", "nanotime"), function(e1, e2) { stop("operation not defined for \"nanotime\" objects") ## #nocov }) ##' @rdname nanotime setMethod("Compare", c("nanotime", "character"), function(e1, e2) { ne2 <- nanotime(e2) callNextMethod(e1, ne2) }) ##' @rdname nanotime setMethod("Compare", c("character", "nanotime"), function(e1, e2) { ne1 <- nanotime(e1) callNextMethod(ne1, e2) }) ##' @rdname nanotime setMethod("Compare", c("nanotime", "POSIXt"), function(e1, e2) { ne2 <- nanotime(e2) callNextMethod(e1, ne2) }) ##' @rdname nanotime setMethod("Compare", c("POSIXt", "nanotime"), function(e1, e2) { ne1 <- nanotime(e1) callNextMethod(ne1, e2) }) ##' @rdname nanotime setMethod("Compare", c("nanotime", "ANY"), function(e1, e2) { if (inherits(e2, "nanotime")) { e2 <- S3Part(e2, strictS3=TRUE) } callNextMethod(S3Part(e1, strictS3=TRUE), e2) }) ##' @rdname nanotime setMethod("Logic", c("nanotime", "ANY"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @rdname nanotime setMethod("Logic", c("ANY", "nanotime"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @rdname nanotime setMethod("Math", c("nanotime"), function(x) { ## this is the same error message that R gives for abs("A") stop("non-numeric argument to mathematical function") }) ##' @rdname nanotime setMethod("Math2", c("nanotime"), function(x, digits) { ## this is the same error message that R gives for round("A") stop("non-numeric argument to mathematical function") }) ##' @rdname nanotime setMethod("Summary", c("nanotime"), function(x, ..., na.rm = FALSE) { ## this is the same error message that R gives for sum("A") stop("invalid 'type' (nanotime) of argument") }) ##' @rdname nanotime setMethod("min", c("nanotime"), function(x, ..., na.rm = FALSE) { new("nanotime", callNextMethod()) }) ##' @rdname nanotime setMethod("max", c("nanotime"), function(x, ..., na.rm = FALSE) { new("nanotime", callNextMethod()) }) ##' @rdname nanotime setMethod("range", c("nanotime"), function(x, ..., na.rm = FALSE) { new("nanotime", callNextMethod()) }) ##' @rdname nanotime setMethod("Complex", c("nanotime"), function(z) { ## this is the same error message that R gives for Arg("A") stop("non-numeric argument to function") }) ## ----------- non ops ##' @rdname nanotime setMethod("[[", signature("nanotime"), function (x, i, j, ..., drop=FALSE) { new("nanotime", callNextMethod()) }) ##' @rdname nanotime setMethod("[", signature("nanotime", "numeric"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanotime' subsetting") } if (isTRUE(any(i < 0))) { new("nanotime", S3Part(x, strictS3=TRUE)[i]) } else { nanotime_subset_numeric_impl(x, i) } }) ##' @rdname nanotime setMethod("[", signature("nanotime", "logical"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanotime' subsetting") } nanotime_subset_logical_impl(x, i) }) ##' @rdname nanotime setMethod("[", signature("nanotime", "character"), function (x, i, j, ..., drop=FALSE) { ## we don't implement 'period_subset_character_impl' but ## do the gymnastic of finding the NAs here at R level; ## it's not as efficient, but using 'character' indexing ## is by itself inefficient, so the overhead should have ## no practical consequences. if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanotime' subsetting") } na_index <- !(i %in% names(x)) | is.na(i) res <- new("nanotime", S3Part(x, strictS3=TRUE)[i]) res[na_index] <- NA_nanotime_ res }) ##' @rdname nanotime setMethod("[", signature("nanotime", "ANY"), function (x, i, j, ..., drop=FALSE) { stop("']' not defined on 'nanotime' for index of type 'ANY'") }) ##' @rdname nanotime setMethod("[<-", signature("nanotime"), function (x, i, j, ..., value) { new("nanotime", callNextMethod()) }) ##' @rdname nanotime c.nanotime <- function(...) { nanotime(c.integer64(...)) } ##' @rdname nanotime ##' @name nanotime-package NULL ##' @rdname nanotime setMethod("names<-", signature("nanotime"), function(x, value) { names(S3Part(x, strictS3=TRUE)) <- value x }) ##' @rdname nanotime setMethod("is.na", signature("nanotime"), function(x) { callNextMethod(S3Part(x, strictS3=TRUE)) }) ##' Sequence Generation ##' ##' Generate a sequence of \code{nanotime} ##' ##' @param ... arguments passed to or from methods; the only ##' interesting additional argument is \code{tz} where the ##' \code{to} argument is of type \code{nanoperiod} ##' @param from,to the starting and (maximal) end values of the ##' sequence ##' @param by \code{nanoduration} or \code{nanoperiod} increment of ##' the sequence; note that if the class is \code{nanoperiod} the ##' additional argument \code{tz} must be speficied and is of ##' \code{character} type indicating a timezone ##' @param length.out integer indicating the desired length of the sequence ##' @param along.with take the length from the length of this argument. ##' @examples ##' \dontrun{ ##' from <- as.nanotime("2018-01-14T12:44:00+00:00") ##' to <- as.nanotime("2019-01-14T12:44:00+00:00") ##' seq(from, to, by=as.nanoperiod("1m"), tz="America/New_York") ##' seq(from, by=as.nanoperiod("1y"), length.out=4, tz="Europe/London") ##' } ##' @method seq nanotime seq.nanotime <- function(from, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...) { if((One <- nargs() == 1L)) { stop("'seq.nanotime' cannot be called with only one argument") } if (sum(is.null(to), is.null(by), is.null(length.out) && is.null(along.with)) > 1) { stop("at least two of 'to', 'by', and 'length.out' or 'along.with' must be specified") } is.logint <- function(.) (is.integer(.) || is.logical(.)) && !is.object(.) if (!missing(along.with) && !is.null(along.with)) { length.out <- length(along.with) } else if(!missing(length.out) && !is.null(length.out)) { len <- length(length.out) if(!len) stop("argument 'length.out' must be of length 1") if(len > 1L) { warning("first element used of 'length.out' argument") length.out <- length.out[1L] } if(!(intn1 <- is.logint(length.out))) length.out <- as.numeric(ceiling(length.out)) } if (length(from) != 1L) stop("'from' must be of length 1") if (!missing(to) && !is.null(to) && length(to) != 1L) stop("'to' must be of length 1") if (!missing(to) && !is.null(to) && !(inherits(to, "nanotime"))) stop("'to' must be a 'nanotime'") if (is.null(length.out)) { if (missing(by) || is.null(by)) stop("'by' must be specified if 'length.out' is NULL") else { # dealing with 'by' if (length(by) != 1L) stop("'by' must be of length 1") if (inherits(by, "nanoperiod")) { ## fish out the 'tz' parameter: args <- list(...) if (!any("tz" %in% names(args))) { stop("'tz' is a mandatory argument for sequences with a 'period' step") } period_seq_from_to_impl(from, to, by, args$tz) } else { nanotime(seq(as.integer64(from), as.integer64(to), by=by)) } } } else if(!is.finite(length.out) || length.out < 0L) stop("'length.out' must be a non-negative number") else if (length.out == 0L) nanotime() else if (missing(by) || is.null(by)) { ## cannot be with 'period', so just call the S3 function: ## calculate 'by' because of 'bit64' bug: by = as.integer64((to - from) / (length.out - 1)) nanotime(seq(as.integer64(from), as.integer64(to), by, NULL, NULL, ...)) } else if (missing(to) || is.null(to)) { if (length(by) != 1L) stop("'by' must be of length 1") if (inherits(by, "nanoperiod")) { ## fish out the 'tz' parameter: args <- list(...) if (!any("tz" %in% names(args))) { stop("'tz' is a mandatory argument for sequences with a 'period' step") } period_seq_from_length_impl(from, by, as.integer64(length.out), args$tz) } else { nanotime(seq(as.integer64(from), by=as.integer64(by), length.out=length.out, along.with=along.with, ...)) } } else stop("too many arguments") } ##' @rdname seq.nanotime setMethod("seq", c("nanotime"), seq.nanotime) ##' Test if Two Objects are (Nearly) Equal ##' ##' Compare \code{target} and \code{current} testing \sQuote{near ##' equality}. If they are different, comparison is still made to ##' some extent, and a report of the differences is returned. Do not ##' use \code{all.equal} directly in \code{if} expressions---either ##' use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if ##' appropriate. ##' ##' @param target,current \code{nanotime} arguments to be compared ##' @param ... further arguments for different methods ##' @param tolerance numeric >= 0. Differences smaller than ##' \code{tolerance} are not reported. The default value is close ##' to \code{1.5e-8}. ##' @param scale \code{NULL} or numeric > 0, typically of length 1 or ##' \code{length(target)}. See \sQuote{Details}. ##' @param countEQ logical indicating if the \code{target == current} cases should be ##' counted when computing the mean (absolute or relative) ##' differences. The default, \code{FALSE} may seem misleading in ##' cases where \code{target} and \code{current} only differ in a few ##' places; see the extensive example. ##' @param formatFUN a \code{function} of two arguments, \code{err}, the relative, absolute ##' or scaled error, and \code{what}, a character string indicating ##' the _kind_ of error; maybe used, e.g., to format relative and ##' absolute errors differently. ##' @param check.attributes logical indicating if the \code{attributes} of \code{target} ##' and \code{current} (other than the names) should be compared. ##' ##' @seealso \code{\link{identical}}, \code{\link{isTRUE}}, ##' \code{\link{==}}, and \code{\link{all}} for exact equality ##' testing. ##' ##' @method all.equal nanotime ##' all.equal.nanotime <- function(target, current, tolerance = sqrt(.Machine$double.eps), scale = NULL, countEQ = FALSE, formatFUN = function(err, what) format(err), ..., check.attributes = TRUE) { if (inherits(target, "nanotime")) target <- as.integer64(target) if (inherits(current, "nanotime")) current <- as.integer64(current) if (!is.numeric(tolerance)) stop("'tolerance' should be numeric") if (!is.numeric(scale) && !is.null(scale)) stop("'scale' should be numeric or NULL") if (!is.logical(check.attributes)) stop(gettextf("'%s' must be logical", "check.attributes"), domain = NA) msg <- NULL msg <- if (check.attributes) attr.all.equal(target, current, tolerance = tolerance, scale = scale, ...) if (data.class(target) != data.class(current)) { msg <- c(msg, paste0("target is ", data.class(target), ", current is ", data.class(current))) return(msg) } lt <- length(target) lc <- length(current) cplx <- is.complex(target) if (lt != lc) { if (!is.null(msg)) msg <- msg[-grep("\\bLengths\\b", msg)] msg <- c(msg, paste0(if (cplx) "Complex" else "Numeric", ": lengths (", lt, ", ", lc, ") differ")) return(msg) } out <- is.na(target) if (any(out != is.na(current))) { msg <- c(msg, paste("'is.NA' value mismatch:", sum(is.na(current)), "in current", sum(out), "in target")) return(msg) } out <- out | target == current if (all(out)) return(if (is.null(msg)) TRUE else msg) if (countEQ) { N <- length(out) sabst0 <- sum(abs(target[out])) } else { sabst0 <- 0 } target <- target[!out] current <- current[!out] if (!countEQ) N <- length(target) ## the following is in the orignal function, but can't be reached here: ## if (is.integer(target) && is.integer(current)) ## target <- as.double(target) xy <- sum(abs(target - current))/N what <- if (is.null(scale)) { xn <- (sabst0 + sum(abs(target)))/N if (is.finite(xn) && xn > tolerance) { xy <- xy/xn "relative" } else { "absolute" } } else { stopifnot(all(scale > 0)) xy <- xy/scale if (all(abs(scale - 1) < 1e-07)) "absolute" else "scaled" } if (cplx) what <- paste(what, "Mod") # nocov if (is.na(xy) || xy > tolerance) msg <- c(msg, paste("Mean", what, "difference:", formatFUN(xy, what))) if (is.null(msg)) { TRUE # nocov } else msg } ##' @rdname all.equal.nanotime setMethod("all.equal", c(target = "nanotime", current="ANY"), all.equal.nanotime) ##' @rdname nanotime NA_nanotime_ <- nanotime(NA) ##' Get a component of a date time ##' ##' Get a component of a date time. \code{nano_wday} returns the ##' numeric position in a week, with Sunday == 0. \code{nano_mday} ##' returns the numeric day (i.e. a value from 1 to ##' 31). \code{nano_month} returns the month (i.e. a value from 1 to ##' 12). \code{nano_year} returns the year. ##' ##' Note that the \code{tz} parameter is mandatory because the day ##' boundary is different depending on the time zone and ##' \code{nanotime} does not store the timezone as it is just an ##' offset in nanoseconds from the epoch. ##' ##' @param x a \code{nanotime} object ##' @param tz \code{character} a string representing a timezone ##' @examples ##' \dontrun{ ##' nano_wday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/New_York") ##' nano_wday(as.nanotime("2020-03-14 23:32:00 America/New_York"), "Europe/Paris") ##' nano_mday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/New_York") ##' nano_mday(as.nanotime("2020-03-14 23:32:00 America/New_York"), "Europe/Paris") ##' nano_month(as.nanotime("2020-12-31 23:32:00-04:00"), "America/New_York") ##' nano_month(as.nanotime("2020-12-31 23:32:00 America/New_York"), "Europe/Paris") ##' nano_year(as.nanotime("2020-12-31 23:32:00-04:00"), "America/New_York") ##' nano_year(as.nanotime("2020-12-31 23:32:00 America/New_York"), "Europe/Paris") ##' } ##' ##' @rdname nano_year ##' @aliases nano_wday ##' @aliases nano_wday,nanotime-method nano_mday,nanotime-method ##' @aliases nano_month,nanotime-method nano_year,nanotime-method ##' setGeneric("nano_wday", function(x, tz) standardGeneric("nano_wday")) setMethod("nano_wday", c("nanotime"), function(x, tz) nanotime_wday_impl(x, tz)) ##' @rdname nano_year ##' @aliases nano_mday ##' setGeneric("nano_mday", function(x, tz) standardGeneric("nano_mday")) setMethod("nano_mday", c("nanotime"), function(x, tz) nanotime_mday_impl(x, tz)) ##' @rdname nano_year ##' @aliases nano_month ##' setGeneric("nano_month", function(x, tz) standardGeneric("nano_month")) setMethod("nano_month", c("nanotime"), function(x, tz) nanotime_month_impl(x, tz)) ##' @rdname nano_year ##' setGeneric("nano_year", function(x, tz) standardGeneric("nano_year")) setMethod("nano_year", c("nanotime"), function(x, tz) nanotime_year_impl(x, tz)) ## rounding ops: ##' Rounding down or up a \code{nanotime} type ##' ##' The functions \code{nano_floor} and \code{nano_ceiling} round down or up, respectively. Although ##' the underlying implementation of \code{nanotime} has negative numbers for values before ##' 1970-01-01 UTC, the rounding is always done backward in time for \code{nano_floor} and forward ##' in time for \code{nano_ceiling}. The functions take a \code{nanotime} argument \code{x} which is ##' the instance to round, together with a second argument \code{precision} which indicates an ##' arbitrary precision to which the rounding should be performed. This argument can be either a ##' \code{nanoduration} or or a \code{nanoperiod}. In the latter case, the argument \code{tz} must ##' also be specified in order to give the \code{nanoperiod} a meaning. Finally, the \code{nanotime} ##' argument \code{origin} can be optionally specified to fix the rounding to a specific point in ##' time. ##' ##' This flexible rounding must be understood in the context of a vector. The rounding precision can ##' then be considered as an interval that defines a grid over which the elements are either ##' assigned to the starting value of the interval to which they belong (\code{nano_floor}) or the ##' ending value of the interval to which they belong (\code{nano_ceiling}). This allows for a ##' grouping of a \code{nanotime} vector on which a statistic may then be run. In the examples ##' below, such a use case is shown in the context of a \code{data.table} object. ##' ##' If "business" concepts such as month or days are needed, the \code{argument} precision must be ##' of type \code{period}. It is then mandatory to specify the timezone argument \code{tz} as this ##' ensures timezone correctness of the intervals including for example for the rare hourly ##' transitions of some countries going from a timezone with a whole hour difference with UTC to one ##' with a fractional hour difference. In the case of a \code{period}, the functions align the ##' rounding if the precision is an integer divisor of a larger quantity. For instance, if one ##' specifies a rounding of 6 hours, a divisor of a day, the hours are aligned on days and the ##' rounding is made to a grid at hours 0, 6, 12 and 18 in the specified timezone. If the precision ##' is not a divisor, the grid is aligned to the nearest hour before the first element of the vector ##' to round. ##' ##' The argument \code{origin} controls the reference point of the rounding, allowing arbitrary ##' specification of the reference point of the rounding. ##' ##' @param x a \code{nanotime} object which must be sorted ##' @param precision a \code{nanoduration} or \code{nanoperiod} object ##' indicating the rounding precision ##' @param ... for future additional arguments ##' @examples ##' \dontrun{ ##' ## "classic" rounding: ##' nano_floor(as.nanotime("2010-10-10 11:12:15 UTC"), as.nanoduration("01:00:00")) ##' ## rounding with arbitrary precision: ##' nano_floor(as.nanotime("2010-10-10 11:12:15 UTC"), as.nanoduration("06:00:00")) ##' nano_floor(as.nanotime("2010-10-10 11:23:15 UTC"), as.nanoduration("00:15:00")) ##' nano_ceiling(as.nanotime("2010-10-10 11:23:15 UTC"), as.nanoduration("01:15:23")) ##' ## controlling the reference point via the 'origin' argument: ##' nano_ceiling(as.nanotime("2010-10-10 11:23:15 UTC"), ##' as.nanoduration("01:15:23"), ##' origin=as.nanotime("2010-10-10 11:23:15 UTC")) ##' ## using business concepts and rounding across a daylight saving change: ##' v <- seq(as.nanotime("2020-03-08 America/New_York"), ##' by=as.nanoperiod("06:00:00"), length.out=8, tz="America/New_York") ##' print(nano_floor(v, as.nanoperiod("1d"), tz="America/New_York"), tz="America/New_York") ##' ## using the concept in a 'data.table': ##' library(data.table) ##' n <- 3 * 24 ##' idx <- seq(as.nanotime("2020-03-07 America/New_York"), ##' by=as.nanoperiod("01:00:00"), length.out=n, tz="America/New_York") ##' dt <- data.table(idx, a=1:n, b=2:(n+1)) ##' dt_mean <- dt[, list(mean = mean(a)), ##' by=nano_ceiling(idx, as.nanoperiod("1d"), tz="America/New_York")] ##' } ##' ##' @aliases nano_floor ##' ##' @rdname rounding setGeneric("nano_ceiling", def = function(x, precision, ...) standardGeneric("nano_ceiling")) ##' @rdname rounding setGeneric("nano_floor", def = function(x, precision, ...) standardGeneric("nano_floor")) ##' Replicate Elements ##' ##' Replicates the values in 'x' similarly to the default method. ##' ##' @param x a vector of \code{nanotime} ##' @param ... further arguments: ##' ##' 'times' an integer-valued vector giving the (non-negative) ##' number of times to repeat each element if of length ##' 'length(x)', or to repeat the whole vector if of length ##' 1. Negative or 'NA' values are an error. A 'double' ##' vector is accepted, other inputs being coerced to an ##' integer or double vector. ##' ##' 'length.out' non-negative integer. The desired length of the ##' output vector. Other inputs will be coerced to a double ##' vector and the first element taken. Ignored if 'NA' or ##' invalid. ##' ##' 'each' non-negative integer. Each element of 'x' is repeated ##' 'each' times. Other inputs will be coerced to an integer ##' or double vector and the first element taken. Treated as ##' '1' if 'NA' or invalid. setMethod("rep", c(x = "nanotime"), function(x, ...) { new("nanotime", callNextMethod()) }) ##' @rdname nanotime as.character.nanotime <- function(x, ...) { format(x, ...) } nanotime/R/nanoival.R0000644000176200001440000007725614211171532014235 0ustar liggesusers## TODO: ## - prevent matrix, array, cbind, rbind, compared with non-interval ## ##' @rdname nanoival setClass("nanoival", contains="complex") ##' Interval type with nanosecond precision ##' ##' \code{nanoival} is a time interval type (an S4 class) with ##' nanosecond precision. One of its purposes is to allow quick ##' subsetting of a \code{nanotime} vector. \code{nanoival} is ##' composed of a \code{nanotime} pair which defines the start and end ##' of the time interval. Additionally, it has a pair of logical ##' values which determine if the start and end of the time interval ##' are open (true) or closed (false). ##' ##' An interval object can be constructed with the constructor ##' \code{nanoival} which takes as arguments two \code{nanotime} ##' objects that define the start and the end of the interval, ##' together with two \code{logical} arguments that define if the ##' start and the end of the interval are open (true) or closed ##' (false) (note that these objects can all be vector, and therefore ##' the interval object is not necessarily scalar). Alternatively, an ##' interval can be constructed with a \code{character}: the format ##' follows that of \code{nanotime}; the start time is preceeded by ##' either \code{-} or \code{+} indicating if the interval start is ##' open (-) or closed (+); the start and end times are separated by ##' an arrow \code{->}; the end is folloed by either \code{-} or ##' \code{+} which have the same semantics as the start time. ##' ##' The most important set of methods defined for \code{interval} are ##' set functions \code{intersect}, \code{union} and \code{setdiff}. ##' ##' Additionally, \code{interval} allows the subsetting into a ##' \code{nanotime} vector. Note that subsetting is allowed only if ##' the \code{nanotime} vector is sorted. ##' ##' Finally, accessors are provided to get the interval start ##' (\code{start}), the end (\code{end}), the open/close status of the ##' start (\code{sopen}) and the open/close status of the end ##' (\code{eopen}). The former return a \code{nanotime} while the ##' latter return a \code{logical}. ##' ##' @section Output Format: ##' ##' Formatting and character conversion for \code{nanoival} objects is ##' identical to \code{nanotime} objects. The default format is ##' ISO3339 compliant: \code{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez}. It ##' specifies a standard ISO 8601 part for date and time --- as well ##' as nine digits of precision for fractional seconds (down to ##' nanoseconds) and on offset (typically zero as we default to UTC). ##' It can be overriden by using \code{options()} with the key of ##' \code{nanotimeFormat} and a suitable value. Similarly, ##' \code{nanotimeTz} can be used to select a different timezone. ##' ##' @param x,from a \code{nanoival} object ##' @param tz \code{character} indicating a timezone ##' @param ... further arguments passed to or from methods. ##' @param e1 Operand of class \code{nanoival} ##' @param e2 Operand of class \code{nanoival} ##' @param format A character string. Can also be set via ##' \code{options("nanotimeFormat")} and uses ##' \sQuote{\%Y-\%m-\%dT\%H:\%M:\%E9S\%Ez} as a default and ##' fallback ##' @param object argument for method \code{show} ##' @param i index specifying elements to extract or replace. ##' @param j Required for \code{[} signature but ignored here ##' @param drop Required for \code{[} signature but ignored here ##' @param value argument for \code{nanoival-class} ##' @param start \code{nanotime} start of interval ##' @param end \code{nanotime} end of interval ##' @param sopen logical indicating if the start of the interval is open ##' @param eopen logical indicating if the end of the interval is open ##' @param quote indicates if the output of \code{print} should be ##' quoted ##' @return A nanoival object ##' @author Dirk Eddelbuettel ##' @author Leonardo Silvestri ##' @examples ##' \dontrun{ ##' ## creating a \code{nanoival}, with the start time included ('+') and the end ##' ## time excluded ('-') ##' as.nanoival("+2012-03-01T21:21:00.000000001+00:00->2015-01-01T21:22:00.000000999+04:00-") ##' ##' ## a \code{nanoival} can also be created with a pair of \code{nanotime} objects, a start ##' ## and an end, and optionally two logicals determining if the interval start(end) are open ##' ## or closed; by default the start is closed and end is open: ##' start <- nanotime("2012-03-01T21:21:00.000000001+00:00") ##' end <- nanotime("2013-03-01T21:21:00.000000001+00:00") ##' nanoival(start, end) ##' ##' ## a vector of 'nanotime' can be subsetted by a 'nanoival': ##' one_second <- 1e9 ##' a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) ##' idx <- c(as.nanoival("-2012-12-12 12:12:10+00:00 -> 2012-12-12 12:12:14+00:00-"), ##' as.nanoival("+2012-12-12 12:12:18+00:00 -> 2012-12-12 12:12:20+00:00+")) ##' a[idx] ##' } ##' @aliases +,ANY,nanoival-method ##' @aliases +,nanoival,ANY-method ##' @aliases +,nanoival,nanoival-method ##' @aliases -,ANY,nanoival-method ##' @aliases -,nanoival,ANY-method ##' @aliases -,nanoival,nanoival-method ##' @aliases Arith,nanoival,ANY-method ##' @aliases Compare,nanoival,ANY-method ##' @aliases Complex,nanoival-method ##' @aliases Logic,ANY,nanoival-method ##' @aliases Logic,nanoival,ANY-method ##' @aliases Logic,nanoival,nanoival-method ##' @aliases Math2,nanoival-method ##' @aliases Math,nanoival-method ##' @aliases Summary,nanoival-method ##' ##' @seealso \code{\link{intersect.idx}}, \code{\link{setdiff.idx}}, ##' @rdname nanoival nanoival <- function(start, end, sopen=FALSE, eopen=TRUE) { if (nargs() == 0) { new("nanoival", as.complex(NULL)) } else { nanoival_new_impl(as.integer64(start), as.integer64(end), as.logical(sopen), as.logical(eopen)) } } ##' @noRd setGeneric("nanoival.start", function(x) standardGeneric("nanoival.start")) ##' @rdname nanoival ##' @aliases nanoival.start setMethod("nanoival.start", "nanoival", function(x) { res <- nanoival_get_start_impl(x) oldClass(res) <- "integer64" new("nanotime", res) }) ##' @noRd setGeneric("nanoival.end", function(x) standardGeneric("nanoival.end")) ##' @rdname nanoival ##' @aliases nanoival.end setMethod("nanoival.end", "nanoival", function(x) { res <- nanoival_get_end_impl(x) oldClass(res) <- "integer64" new("nanotime", res) }) ##' @noRd setGeneric("nanoival.sopen", function(x) standardGeneric("nanoival.sopen")) ##' @rdname nanoival ##' @aliases nanoival.sopen setMethod("nanoival.sopen", "nanoival", function(x) { nanoival_get_sopen_impl(x) }) ##' @noRd setGeneric("nanoival.eopen", function(x) standardGeneric("nanoival.eopen")) ##' @rdname nanoival ##' @aliases nanoival.eopen setMethod("nanoival.eopen", "nanoival", function(x) { nanoival_get_eopen_impl(x) }) ##' @rdname nanoival format.nanoival <- function(x, ...) { if (length(x) == 0) { "nanoival(0)" } else { s <- paste0(ifelse(nanoival.sopen(x), "-", "+"), format(nanoival.start(x), ...), " -> ", format(nanoival.end(x), ...), ifelse(nanoival.eopen(x), "-", "+")) if (!is.null(attr(x, "names", exact=TRUE))) { names(s) <- names(x) } s[nanoival_isna_impl(x)] = NA_character_ s } } ##' @rdname nanoival setMethod("print", "nanoival", function(x, quote=FALSE, ...) { s <- format(x, ...) max.print <- options()$max.print if (length(x) > max.print) { ## #nocov start f <- head(x, max.print) print(f, quote=quote) cat(paste(' [ reached getOption("max.print") -- omitted', length(x) - max.print, "entries ]\n")) } ## #nocov end else { print(s, quote=quote) } invisible(s) }) ##' @rdname nanoival setMethod("show", signature("nanoival"), function(object) print(object)) .secondaryNanoivalParse <- function(x, format="", tz="") { format <- .getFormat(format) tz <- .getTz(x, tz) ## parse the +-, split on -> and process the two s1 = substr(x, 1, 1) if (any(s1 != '-' & s1 != '+')) { stop("`nanoival` must start with '+' or '-'") } sopen <- s1 == "-" xlen <- nchar(x) e1 <- substr(x, xlen, xlen) if (any(e1 != '-' & e1 != '+')) { stop("`nanoival` must end with '+' or '-'") } eopen <- e1 == "-" start_stop <- strsplit(substr(x, 2, xlen-1), "->") start <- sapply(start_stop, function(x) head(x, 1)) end <- sapply(start_stop, function(x) tail(x, 1)) res <- nanoival(nanotime(start, format, tz), nanotime(end, format, tz), sopen, eopen) names(res) <- names(x) res } ##' @noRd setGeneric("as.nanoival", function(from, format="", tz="") standardGeneric("as.nanoival")) ##' @rdname nanoival ##' @aliases as.nanoival setMethod("as.nanoival", "character", function(from, format="", tz="") { if (!is.character(tz)) { stop("argument 'tz' must be of type 'character'") } tryCatch(nanoival_make_impl(from, tz), error=function(e) { if (grepl("Cannot retrieve timezone", e$message)) { stop(e$message) } else { .secondaryNanoivalParse(from, format, tz) } }) }) setAs("character", "nanoival", function(from) as.nanoival(from)) ##' @rdname nanoival setMethod("as.nanoival", "NULL", function(from, format="", tz="") { new("nanoival", as.complex(NULL)) }) ##' @rdname nanoival setMethod("as.nanoival", "missing", function(from, format="", tz="") { new("nanoival", as.complex(NULL)) }) ##' @rdname nanoival setMethod("is.na", "nanoival", function(x) { nanoival_isna_impl(x) }) ##' @rdname nanoival setMethod("is.na<-", "nanoival", function(x, value) { x[value] <- NA_nanoival_ x }) ## ------------ logical comp ##' @rdname nanoival setMethod("<", c("nanoival", "nanoival"), function(e1, e2) { nanoival_lt_impl(e1, e2) }) ##' @rdname nanoival setMethod("<=", c("nanoival", "nanoival"), function(e1, e2) { nanoival_le_impl(e1, e2) }) ##' @rdname nanoival setMethod(">", c("nanoival", "nanoival"), function(e1, e2) { nanoival_gt_impl(e1, e2) }) ##' @rdname nanoival setMethod(">=", c("nanoival", "nanoival"), function(e1, e2) { nanoival_ge_impl(e1, e2) }) ##' @rdname nanoival setMethod("==", c("nanoival", "nanoival"), function(e1, e2) { nanoival_eq_impl(e1, e2) }) ##' @rdname nanoival setMethod("!=", c("nanoival", "nanoival"), function(e1, e2) { nanoival_ne_impl(e1, e2) }) ## ------------ `-` ##' @noRd setMethod("-", c("nanoival", "ANY"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoival setMethod("-", c("nanoival", "integer64"), function(e1, e2) { new("nanoival", nanoival_minus_impl(e1, e2)) }) ##' @rdname nanoival setMethod("-", c("nanoival", "numeric"), function(e1, e2) { new("nanoival", nanoival_minus_impl(e1, as.integer64(e2))) }) ##' @noRd setMethod("-", c("ANY", "nanoival"), function(e1, e2) { stop("invalid operand types") }) ##' @noRd setMethod("-", c("nanoival", "nanoival"), function(e1, e2) { stop("invalid operand types") }) ## ----------- `+` ##' @noRd setMethod("+", c("nanoival", "nanoival"), function(e1, e2) { stop("invalid operand types") }) ##' @noRd setMethod("+", c("nanoival", "ANY"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoival setMethod("+", c("nanoival", "integer64"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e1, e2)) }) ##' @rdname nanoival setMethod("+", c("nanoival", "numeric"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e1, as.integer64(e2))) }) ##' @noRd setMethod("+", c("ANY", "nanoival"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoival setMethod("+", c("integer64", "nanoival"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e2, e1)) }) ##' @rdname nanoival setMethod("+", c("numeric", "nanoival"), function(e1, e2) { new("nanoival", nanoival_plus_impl(e2, as.integer64(e1))) }) ##' @noRd setMethod("+", c("nanoival", "nanoival"), function(e1, e2) { stop("invalid operand types") }) ## ---------- other ops ##' @noRd setMethod("Arith", c("nanoival", "ANY"), function(e1, e2) { stop("operation not defined for \"nanoival\" objects") }) ##' @noRd setMethod("Compare", c("nanoival", "ANY"), function(e1, e2) { stop("invalid operand types") }) ##' @noRd setMethod("Logic", c("nanoival", "nanoival"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @noRd setMethod("Logic", c("nanoival", "ANY"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @noRd setMethod("Logic", c("ANY", "nanoival"), function(e1, e2) { ## this is the same error message that R gives for "A" | "A" stop("operations are possible only for numeric, logical or complex types") }) ##' @noRd setMethod("Math", c("nanoival"), function(x) { ## this is the same error message that R gives for abs("A") stop("non-numeric argument to mathematical function") }) ##' @noRd setMethod("Math2", c("nanoival"), function(x, digits) { ## this is the same error message that R gives for round("A") stop("non-numeric argument to mathematical function") }) ##' @noRd setMethod("Summary", c("nanoival"), function(x, ..., na.rm = FALSE) { ## this is the same error message that R gives for sum("A") stop("invalid 'type' (nanoival) of argument") }) ##' @noRd setMethod("Complex", c("nanoival"), function(z) { ## this is the same error message that R gives for Arg("A") stop("non-numeric argument to function") }) ## ----------- non ops ##' @rdname nanoival setMethod("[[", signature("nanoival"), function (x, i, j, ..., drop=FALSE) { new("nanoival", callNextMethod()) }) ##' @rdname nanoival setMethod("[", signature("nanoival", "logical"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoival' subsetting") } nanoival_subset_logical_impl(x, i) }) ##' @rdname nanoival setMethod("[", signature("nanoival", "numeric"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoival' subsetting") } if (isTRUE(any(i < 0))) { new("nanoival", unclass(x)[i]) } else { nanoival_subset_numeric_impl(x, i) } }) ##' @rdname nanoival setMethod("[", signature("nanoival", "character"), function (x, i, j, ..., drop=FALSE) { ## we don't implement 'period_subset_character_impl' but ## do the gymnastic of finding the NAs here at R level; ## it's not as efficient, but using 'character' indexing ## is by itself inefficient, so the overhead should have ## no practical consequences. if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoival' subsetting") } na_index <- !(i %in% names(x)) | is.na(i) res <- new("nanoival", unclass(x)[i]) res[na_index] <- NA_nanoival_ res }) ##' @rdname nanoival setMethod("[", signature("nanoival", "ANY"), function (x, i, j, ..., drop=FALSE) { stop("']' not defined for on 'nanoival' for index of type 'ANY'") }) ##' @rdname nanoival setMethod("[<-", signature("nanoival", "logical", "ANY", "nanoival"), function (x, i, j, ..., value) { new("nanoival", callNextMethod()) }) ##' @rdname nanoival c.nanoival <- function(...) { args <- list(...) s3args <- lapply(args, function (x) S3Part(x, strictS3=TRUE)) res <- do.call(c, s3args) names(res) <- names(args) new("nanoival", res) } ## S4 'c' doesn't handle names correctly, and couldn't find a way to rectify that: ## ##' @rdname nanoival ## ## setMethod("c", ## signature("nanoival"), ## function(x, ...) { ## print("method ccc") ## args <- list(...) ## res <- callNextMethod() ## names(res) <- names(args) ## print(names(args)) ## new("nanoival", res) ## }) ##' @rdname nanoival setMethod("t", c("nanoival"), function(x) { ## identity, like POSIXct, because nanoival doesn't support arrays x }) ## ##' @rdname nanoival ## ## setMethod("cbind2", ## signature("nanoival", "nanoival"), ## function (x, y, ...) { ## print(dimnames(x)) ## print("calling next method") ## res <- callNextMethod() ## print(attributes(res)) ## new("nanoival", res) ## }) ## ##' @rdname nanoival ## ## setMethod("cbind2", ## signature("nanoival", "nanoival"), ## function (x, y, ...) { ## x <- t(x) ## y <- t(y) ## print(dimnames(x)) ## print("calling next method") ## res <- callNextMethod() ## print(attributes(res)) ## new("nanoival", res) ## }) ## ##' @rdname nanoival ## ## setMethod("rbind2", ## signature("nanoival", "nanoival"), ## function (x, y, ...) { ## print("rbind2") ## dim(x) ## x <- t(x) ## y <- t(y) ## print(dim(x)) ## print(dim(y)) ## print("rbind2 dimnames") ## print(dimnames(x)) ## new("nanoival", callNextMethod()) ## }) ## set functions ## ------------- ##' Set operations ##' ##' Performs set intersection, union and difference between vectors of ##' temporal types from the \code{nanotime} package. ##' ##' Set operations between \code{nanoival} operands allow the ##' construction of complex interval vectors (i.e. a \code{nanoival} ##' vector can specify any number of inclusions and exclusions of ##' time). Set operations between \code{nanotime} and \code{nanoival} ##' allow to subset time vectors with interval vectors. In addition to ##' the generic set functions, the function \code{intersect.idx} is ##' defined which returns the indices of the intersection, and the ##' operator \code{\%in\%} is overloaded for \code{nanotime-nanoival} ##' which returns a logical vector that indicates which elements ##' belong to the interval vector. ##' ##' ##' @param x,y a temporal type ##' @param table \code{nanoival}: used in \code{\%in\%} ##' @return \code{intersect}, \code{union}, \code{setdiff} return ##' temporal types that are the result of the intersection. For ##' instance, set operations on two \code{nanoival} return a ##' \code{nanoival}, whereas intersection between a ##' \code{nanoival} and a \code{nanotime} returns a ##' \code{nanotime}. \code{intersect.idx} return a list of vectors ##' representing the element indices that intersect and ##' \code{setdiff.idx} returns a vector representing the element ##' indices to be removed. ##' @examples ##' \dontrun{ ##' ## a vector of 'nanotime' can be subsetted by a 'nanoival' which is equivalent to 'intersect': ##' one_second <- 1e9 ##' a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) ##' idx <- c(as.nanoival("-2012-12-12 12:12:10+00:00 -> 2012-12-12 12:12:14+00:00-"), ##' as.nanoival("+2012-12-12 12:12:18+00:00 -> 2012-12-12 12:12:20+00:00+")) ##' a[idx] ##' intersect(a, idx) ##' ##' ## 'nanoival' also has the set operations 'union', 'intersect', 'setdiff': ##' a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) ##' i <- as.nanoival("-2012-12-12 12:12:14+00:00 -> 2012-12-12 12:12:18+00:00-") ##' setdiff(a, i) ##' ##' i1 <- as.nanoival("+2012-12-12 12:12:14+00:00 -> 2012-12-12 12:12:17+00:00-") ##' i2 <- as.nanoival("+2012-12-12 12:12:16+00:00 -> 2012-12-12 12:12:18+00:00-") ##' union(i1, i2) ##' ##' ## 'intersect.idx' returns the indices of the intersection: ##' a <- seq(nanotime("2012-12-12 12:12:12+00:00"), length.out=10, by=one_second) ##' idx <- as.nanoival("+2012-12-12 12:12:14+00:00 -> 2012-12-12 12:12:19+00:00+") ##' idx_intersect <- intersect.idx(a, idx) ##' ##' ## Intersection can be performed using these indices: ##' a[idx_intersect$x] ##' ##' ## which is equivalent to: ##' a[idx] ##' ##' ## The logical vector indicating intersection can be obtained like this: ##' a %in% idx ##' } ##' @rdname set_operations ##' setMethod("intersect", c("nanoival", "nanoival"), function(x, y) { x <- sort(x) y <- sort(y) res <- nanoival_intersect_impl(x, y) new("nanoival", res) }) ##' @rdname set_operations setMethod("union", c("nanoival", "nanoival"), function(x, y) { x <- sort(x) y <- sort(y) res <- nanoival_union_impl(x, y) new("nanoival", res) }) ##' @rdname set_operations setMethod("setdiff", c("nanoival", "nanoival"), function(x, y) { x <- sort(x) y <- sort(y) res <- nanoival_setdiff_impl(x, y) new("nanoival", res) }) ## nanotime and nanoival: ## --------------------- ##' @rdname nanoival setMethod("[", signature("nanotime", "nanoival"), function (x, i, ..., drop=FALSE) { if (is.unsorted(x)) stop("x must be sorted") i <- sort(i) nanoival_intersect_time_interval_impl(x, i) }) ##' @noRd setGeneric("intersect.idx", function(x, y) standardGeneric("intersect.idx")) ##' @rdname set_operations ##' @aliases intersect.idx setMethod("intersect.idx", c("nanotime", "nanoival"), function(x, y) { if (is.unsorted(x)) stop("x must be sorted") y <- sort(y) nanoival_intersect_idx_time_interval_impl(x, y) }) ##' @rdname set_operations ##' @method %in% nanotime `%in%.nanotime` <- function(x, table) { if (inherits(table, "nanoival")) { if (is.unsorted(x)) stop("x must be sorted") table <- sort(table) nanoival_intersect_idx_time_interval_logical_impl(x, table) } else { NextMethod() } } ##' @rdname set_operations setMethod("%in%", c("nanotime", "nanoival"), function(x, table) { if (is.unsorted(x)) stop("x must be sorted") ## #nocov table <- sort(table) ## #nocov nanoival_intersect_idx_time_interval_logical_impl(x, table) ## #nocov }) ##' @rdname set_operations setMethod("intersect", c("nanotime", "nanoival"), function(x, y) { x <- sort(x) y <- sort(y) nanoival_intersect_time_interval_impl(x, y) }) ##' @rdname set_operations setMethod("setdiff", c("nanotime", "nanoival"), function(x, y) { x <- sort(x) y <- sort(y) res <- nanoival_setdiff_time_interval_impl(x, y) oldClass(res) <- "integer64" new("nanotime", res) }) ##' @noRd setGeneric("setdiff.idx", function(x, y) standardGeneric("setdiff.idx")) ##' @rdname set_operations ##' @aliases setdiff.idx setMethod("setdiff.idx", c("nanotime", "nanoival"), function(x, y) { if (is.unsorted(x)) stop("x must be sorted") y <- sort(y) nanoival_setdiff_idx_time_interval_impl(x, y) }) ## provide 'nanotime'-'nanotime' set operations and document here ## --------------------- ##' @rdname set_operations setMethod("intersect", c("nanotime", "nanotime"), function(x, y) { res <- callNextMethod() oldClass(res) <- "integer64" new("nanotime", res) }) ##' @rdname set_operations setMethod("union", c("nanotime", "nanotime"), function(x, y) { res <- callNextMethod() oldClass(res) <- "integer64" new("nanotime", res) }) ##' @rdname set_operations setMethod("setdiff", c("nanotime", "nanotime"), function(x, y) { res <- callNextMethod() oldClass(res) <- "integer64" new("nanotime", res) }) ## misc functions: ## -------------- ##' Test if Two Objects are (Nearly) Equal ##' ##' Compare \code{target} and \code{current} testing \sQuote{near ##' equality}. If they are different, comparison is still made to ##' some extent, and a report of the differences is returned. Do not ##' use \code{all.equal} directly in \code{if} expressions---either ##' use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if ##' appropriate. ##' ##' @param target,current \code{nanoival} arguments to be compared ##' @param ... further arguments for different methods ##' @param check.attributes logical indicating if the ##' \code{attributes} of \code{target} and \code{current} (other than ##' the names) should be compared. ##' ##' @seealso \code{\link{identical}}, \code{\link{isTRUE}}, ##' \code{\link{==}}, and \code{\link{all}} for exact equality ##' testing. ##' ##' @method all.equal nanoival ##' all.equal.nanoival <- function(target, current, ..., check.attributes = TRUE) all.equal.raw(target, current, ..., check.attributes) ##' @rdname all.equal.nanoival setMethod("all.equal", c(target = "nanoival", current="ANY"), all.equal.nanoival) ##' Test if a \code{nanoival} vector is Not Sorted ##' ##' Test if an object is not sorted (in increasing order), without the ##' cost of sorting it. ##' ##' @param x a \code{nanoival} vector ##' @param na.rm logical. Should missing values be removed before ##' checking? ##' @param strictly logical indicating if the check should be for ##' _strictly_ increasing values. ##' ##' @seealso \code{\link{sort}} ##' setMethod("is.unsorted", "nanoival", function(x, na.rm=FALSE, strictly=FALSE) { if (!is.logical(strictly)) { stop("argument 'strictly' must be a logical") } if (na.rm == TRUE) { nanoival_is_unsorted_impl(x[!is.na(x)], strictly) # we could code this more efficiently! } else { if (any(is.na(x))) { # same here... NA_nanoival_ } else { nanoival_is_unsorted_impl(x, strictly) } } }) ##' Sorting or Ordering Vectors ##' ##' Sort (or _order_) a vector of \code{nanoival} into ascending or ##' descending order ##' ##' @param x a vector of \code{nanoival} ##' @param decreasing logical. Should the sort be increasing or ##' decreasing? ##' @seealso \code{\link{is.unsorted}} ##' setMethod("sort", c("nanoival"), function(x, decreasing=FALSE) { if (!is.logical(decreasing)) { stop("argument 'decreasing' must be logical") } new("nanoival", nanoival_sort_impl(x, decreasing)) }) ##' Sequence Generation ##' ##' Generate a sequence of \code{nanoival} ##' ##' @param ... arguments passed to or from methods; the only ##' interesting additional argument is \code{tz} where the ##' \code{to} argument is of type \code{nanoperiod} ##' @param from,to the starting and (maximal) end values of the ##' sequence ##' @param by \code{nanoduration} or \code{nanoperiod} increment of ##' the sequence; note that if the class is \code{nanoperiod} the ##' additional argument \code{tz} must be speficied and is of ##' \code{character} type indicating a timezone ##' @param length.out an integer desired length of the sequence ##' @param along.with take the length from the length of this argument. ##' @examples ##' \dontrun{ ##' from <- as.nanoival("-2018-01-14T13:00:00+00:00 -> 2018-01-14T15:00:00+00:00+") ##' seq(from, by=as.nanoperiod("1m"), length.out=5, tz="America/New_York") ##' } setMethod("seq", c("nanoival"), function(from, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...) { if (is.null(to)) { start <- seq(nanoival.start(from), by=by, length.out=length.out, along.with=along.with, ...) } else { start <- seq(nanoival.start(from), nanoival.start(to), by, length.out, along.with, ...) } if (is.null(by)) { end <- seq(nanoival.end(from), by=start[2]-start[1], length.out=length(start), ...) } else { end <- seq(nanoival.end(from), by=by, length.out=length(start), ...) } nanoival(start, end, nanoival.sopen(from), nanoival.eopen(from)) }) ##' @rdname nanoival NA_nanoival_ <- new("nanoival", complex(1, -4.9406564584124654418e-324, -4.9406564584124654418e-324)) ##' Replicate Elements ##' ##' Replicates the values in 'x' similarly to the default method. ##' ##' @param x a vector of \code{nanoival} ##' @param ... further arguments: ##' ##' 'times' an integer-valued vector giving the (non-negative) ##' number of times to repeat each element if of length ##' 'length(x)', or to repeat the whole vector if of length ##' 1. Negative or 'NA' values are an error. A 'double' ##' vector is accepted, other inputs being coerced to an ##' integer or double vector. ##' ##' 'length.out' non-negative integer. The desired length of the ##' output vector. Other inputs will be coerced to a double ##' vector and the first element taken. Ignored if 'NA' or ##' invalid. ##' ##' 'each' non-negative integer. Each element of 'x' is repeated ##' 'each' times. Other inputs will be coerced to an integer ##' or double vector and the first element taken. Treated as ##' '1' if 'NA' or invalid. setMethod("rep", c(x = "nanoival"), function(x, ...) { new("nanoival", callNextMethod()) }) ##' @rdname nanoival as.character.nanoival <- function(x, ...) { format(x, ...) } nanotime/R/nanoperiod.R0000644000176200001440000005760014211171755014562 0ustar liggesusers##' @rdname nanoperiod setClass("nanoperiod", contains = "complex") ##' Period type with nanosecond precision ##' ##' \code{nanoperiod} is a length of time type (implemented as an S4 ##' class) with nanosecond precision. It differs from ##' \code{nanoduration} because it is capable of representing calendar ##' months and days. It can thus represent years (12 months) and weeks ##' (7 days). A period is a somewhat abstract representation of time: ##' it is only when anchored to a point in time and in a specific time ##' zone that it is possible to convert it to a specific ##' duration. This means that many of the operations involving periods ##' need the additional argument \code{tz}. ##' ##' @section Constructors: ##' ##' The true constructor is ##' ##' @section Output Format: ##' ##' A \code{nanoperiod} is displayed as months, days, and \code{nanoduration} ##' like this: \code{10m2d/10:12:34.123_453_000}. ##' ##' @section Details: ##' ##' ##' ##' Adding or subtracting \code{nanoperiod} and \code{nanotime} ##' require a timezone as third argument. For this reason it is not ##' possible to use the binary operator `code{+}`. Instead the ##' functions `\code{plus}` and `\code{minus}` are defined. These ##' functions attempt to keep the same offset within a day in the ##' specified timezone: this means for instance that adding a day when ##' that day crosses a time zone adjustment such as a daylight saving ##' time, results in a true time increment of less or more than 24 ##' hours to preserve the offset. Preserving the offset works for ##' increments that are smaller than a day too, provided the increment ##' results in a datetime where the timezone adjustment is valid. When ##' this is not the case, adding a `nanoperiod` behaves in the same ##' way as adding a `nanoduration`. ##' ##' ##' @param x,value An object of class \code{nanoperiod} ##' @param ... further arguments ##' @param e1 Operand of class \code{nanoperiod} ##' @param e2 Operand of class \code{nanoperiod} ##' @param object argument for method \code{show} ##' @param i index specifying elements to extract or replace. ##' @param j Required for \code{[} signature but ignored here ##' @param drop Required for \code{[} signature but ignored here ##' @param months Used in the constructor to indicate the number of ##' months of the \code{nanoperiod} ##' @param days Used in the constructor to indicate the number of ##' days of the \code{nanoperiod} ##' @param duration Used in the constructor to indicate the duration ##' component of the \code{nanoperiod} ##' @param quote indicates if the output of \code{print} should be ##' quoted ##' @param tz \code{character} indicating a timezone ##' @author Dirk Eddelbuettel ##' @author Leonardo Silvestri ##' @examples ##' \dontrun{ ##' p <- nanoperiod(months=12, days=7, duration="01:00:00") ##' print(p) ##' ##' # when adding a \code{nanoperiod} to a \code{nanotime} or to a ##' # \code{nanoival}, a time zone must be specified: ##' y <- nanotime("1970-01-01T00:00:00+00:00") ##' plus(y, p, tz="America/Chicago") ##' } ##' ##' @seealso \code{\link{nanotime}}, \code{\link{nanoduration}}, ##' \code{\link{nanoival}}, \code{\link{nanoperiod.month,nanoperiod-method}} ##' ##' @aliases Compare,ANY,nanoperiod-method Compare,nanoperiod,ANY-method ##' @aliases -,ANY,nanoperiod-method -,nanoperiod,nanotime-method ##' @aliases -,nanotime,nanoperiod-method ##' @aliases /,ANY,nanoperiod-method /,nanoperiod,ANY-method ##' @aliases Complex,nanoperiod-method Math,nanoperiod-method Math2,nanoperiod-method ##' @aliases Summary,nanoperiod-method ##' @aliases minus,nanoperiod,nanoival,character-method ##' ##' @rdname nanoperiod nanoperiod <- function(months=0, days=0, duration=as.nanoduration(0)) { if (nargs() == 0) { as.nanoperiod(NULL) } else { if (!is.numeric(months)) { stop("argument 'months' must be numeric") } if (!is.numeric(days)) { stop("argument 'days' must be numeric") } period_from_parts_impl(as.integer(months), as.integer(days), as.nanoduration(duration)) } } ##' @noRd setGeneric("nanoperiod") ##' @noRd setGeneric("as.nanoperiod", function(x) standardGeneric("as.nanoperiod")) ##' @rdname nanoperiod ##' @aliases as.nanoperiod setMethod("as.nanoperiod", "character", function(x) { period_from_string_impl(x) }) setAs("character", "nanoperiod", function(from) as.nanoperiod(from)) ##' @rdname nanoperiod setMethod("as.nanoperiod", "integer64", function(x) { period_from_integer64_impl(x) }) setAs("integer64", "nanoperiod", function(from) as.nanoperiod(from)) ##' @rdname nanoperiod setMethod("as.nanoperiod", "numeric", function(x) { period_from_double_impl(x) }) setAs("numeric", "nanoperiod", function(from) as.nanoperiod(from)) ##' @rdname nanoperiod setMethod("as.nanoperiod", "integer", function(x) { period_from_integer_impl(x) }) setAs("integer", "nanoperiod", function(from) as.nanoperiod(from)) ##' @rdname nanoperiod setMethod("as.nanoperiod", "nanoduration", function(x) { period_from_integer64_impl(x) }) setAs("nanoduration", "nanoperiod", function(from) as.nanoperiod(from)) ##' @rdname nanoperiod setMethod("as.nanoperiod", "NULL", function(x) { period_from_string_impl(character()) }) ##' @rdname nanoperiod setMethod("as.nanoperiod", "missing", function(x) { period_from_string_impl(character()) }) ##' @rdname nanoperiod setMethod("show", signature("nanoperiod"), function(object) print(object)) ##' @rdname nanoperiod setMethod("print", "nanoperiod", function(x, quote=FALSE, ...) { if (length(x)==0) { print("nanoperiod(0)", quote=quote) } else { print(period_to_string_impl(x), quote=quote) } }) ##' @rdname nanoperiod format.nanoperiod <- function(x, ...) { period_to_string_impl(x) } ##' @rdname nanoperiod setMethod("as.character", signature("nanoperiod"), function(x) { period_to_string_impl(x) }) ##' @rdname nanoperiod setMethod("is.na", "nanoperiod", function(x) { period_isna_impl(x) }) ##' @rdname nanoperiod setMethod("is.na<-", "nanoperiod", function(x, value) { x[value] <- NA_nanoperiod_ x }) ## accessors ## ----------- non ops ##' @rdname nanoperiod setMethod("[[", signature("nanoperiod", "ANY"), function (x, i, j, ..., drop=FALSE) { new("nanoperiod", callNextMethod()) }) ##' @rdname nanoperiod setMethod("[", signature("nanoperiod", "numeric"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoperiod' subsetting") } if (isTRUE(any(i < 0))) { new("nanoperiod", unclass(x)[i]) } else { period_subset_numeric_impl(x, i) } }) ##' @rdname nanoperiod setMethod("[", signature("nanoperiod", "logical"), function (x, i, j, ..., drop=FALSE) { if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoperiod' subsetting") } period_subset_logical_impl(x, i) }) ##' @rdname nanoperiod setMethod("[", signature("nanoperiod", "character"), function (x, i, j, ..., drop=FALSE) { ## we don't implement 'period_subset_character_impl' but ## do the gymnastic of finding the NAs here at R level; ## it's not as efficient, but using 'character' indexing ## is by itself inefficient, so the overhead should have ## no practical consequences. if (!missing(j) || length(list(...)) > 0) { warning("unused indices or arguments in 'nanoperiod' subsetting") } na_index <- !(i %in% names(x)) | is.na(i) res <- new("nanoperiod", unclass(x)[i]) res[na_index] <- NA_nanoperiod_ res }) ##' @rdname nanoperiod setMethod("[", signature("nanoperiod", "ANY"), function (x, i, j, ..., drop=FALSE) { stop("']' not defined on 'nanoperiod' for index of type 'ANY'") }) ##' @rdname nanoperiod setMethod("[<-", signature("nanoperiod", "ANY", "ANY", "ANY"), function (x, i, j, ..., value) { new("nanoperiod", callNextMethod()) }) ##' @rdname nanoperiod c.nanoperiod <- function(...) { args <- list(...) s3args <- lapply(args, function (x) S3Part(x, strictS3=TRUE)) res <- do.call(c, s3args) names(res) <- names(args) new("nanoperiod", res) } ##' @noRd setGeneric("nanoperiod.month", function(x) standardGeneric("nanoperiod.month")) ##' Nanoperiod accessors ##' ##' These functions allow access to the components of a \code{nanoperiod} ##' ##' @rdname nanoperiod.month ##' @aliases nanoperiod.month nanoperiod.day nanoperiod.nanoduration ##' @param x A \code{nanoperiod} ##' @return \code{nanoperiod.month} and \code{nanoperiod.day} return ##' an \code{integer64} whereas \code{nanoperiod.nanoduration} ##' returns a \code{nanoduration} ##' @examples ##' p <- as.nanoperiod("2y1m1d/12:00:00") ##' nanoperiod.month(p) ##' nanoperiod.day(p) ##' nanoperiod.nanoduration(p) ##' @author Dirk Eddelbuettel ##' @author Leonardo Silvestri ##' @seealso \code{\link{nanoduration}} setMethod("nanoperiod.month", "nanoperiod", function(x) { period_month_impl(x) }) ##' @noRd setGeneric("nanoperiod.day", function(x) standardGeneric("nanoperiod.day")) ##' @rdname nanoperiod.month setMethod("nanoperiod.day", "nanoperiod", function(x) { period_day_impl(x) }) ##' @noRd setGeneric("nanoperiod.nanoduration", function(x) standardGeneric("nanoperiod.nanoduration")) ##' @rdname nanoperiod.month setMethod("nanoperiod.nanoduration", "nanoperiod", function(x) { period_duration_impl(x) }) ##' @rdname nanoperiod setMethod("names", signature("nanoperiod"), function(x) { callNextMethod() }) ##' @rdname nanoperiod setMethod("names<-", signature("nanoperiod"), function(x, value) { names(S3Part(x, strictS3=TRUE)) <- value new("nanoperiod", x) }) ## ----------- make sure ops that don't make sense error out ##' @noRd setMethod("Ops", c("nanoperiod", "ANY"), function(e1, e2) { stop("operation not defined for 'nanoperiod' objects") }) ##' @noRd setMethod("Ops", c("ANY", "nanoperiod"), function(e1, e2) { stop("operation not defined for 'nanoperiod' objects") }) ##' @noRd setMethod("Math", c("nanoperiod"), function(x) { stop("operation not defined for 'nanoperiod' objects") }) ##' @noRd setMethod("Math2", c("nanoperiod"), function(x, digits) { stop("operation not defined for 'nanoperiod' objects") }) ##' @noRd setMethod("Summary", c("nanoperiod"), function(x, ..., na.rm = FALSE) { stop("invalid 'type' (nanoperiod) of argument") }) ##' @noRd setMethod("Complex", c("nanoperiod"), function(z) { stop("operation not defined for 'nanoperiod' objects") }) ## ------------ `-` ##' @rdname nanoperiod setMethod("-", c("nanoperiod", "ANY"), function(e1, e2) { if (missing(e2)) { minus_period_impl(e1) } else { stop("invalid operand types") } }) ##' @rdname nanoperiod setMethod("-", c("nanoperiod", "nanoperiod"), function(e1, e2) { minus_period_period_impl(e1, e2) }) ## -- ##' @rdname nanoperiod ##' @aliases -,nanoperiod,ANY-method setMethod("-", c("nanoperiod", "nanoduration"), function(e1, e2) { minus_period_integer64_impl(e1, e2) }) ##' @rdname nanoperiod setMethod("-", c("nanoperiod", "integer64"), function(e1, e2) { minus_period_integer64_impl(e1, e2) }) ##' @noRd setMethod("-", c("nanotime", "nanoperiod"), function(e1, e2) { stop(paste0("binary '-' is not defined for 'nanotime' and 'nanoperiod' objects; instead use 'minus(e1, e2, tz)'")) }) ##' @noRd setMethod("-", c("nanoperiod", "nanotime"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoperiod setMethod("-", c("nanoperiod", "numeric"), function(e1, e2) { minus_period_integer64_impl(e1, as.integer64(e2)) }) ## -- ##' @noRd setMethod("-", c("ANY", "nanoperiod"), function(e1, e2) { stop("invalid operand types") }) ## -- ##' @rdname nanoperiod setMethod("-", c("nanoduration", "nanoperiod"), function(e1, e2) { minus_integer64_period_impl(e1, e2) }) ## -- ##' @rdname nanoperiod setMethod("-", c("integer64", "nanoperiod"), function(e1, e2) { minus_integer64_period_impl(as.integer64(e1), e2) }) ## -- ##' @rdname nanoperiod setMethod("-", c("numeric", "nanoperiod"), function(e1, e2) { minus_integer64_period_impl(as.integer64(e1), e2) }) ## ----------- `+` ##' @rdname nanoperiod ##' @aliases +,ANY,nanoperiod-method setMethod("+", c("nanoperiod", "ANY"), function(e1, e2) { if (missing(e2)) { e1 } else { stop("invalid operand types") } }) ##' @rdname nanoperiod setMethod("+", c("nanoperiod", "nanoperiod"), function(e1, e2) { plus_period_period_impl(e1, e2) }) ## -- ##' @noRd setMethod("+", c("ANY", "nanoperiod"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoperiod setMethod("+", c("nanoperiod", "nanoduration"), function(e1, e2) { plus_period_integer64_impl(e1, S3Part(e2, strictS3=TRUE)) }) ##' @rdname nanoperiod setMethod("+", c("nanoperiod", "integer64"), function(e1, e2) { plus_period_integer64_impl(e1, e2) }) ##' @rdname nanoperiod setMethod("+", c("nanoperiod", "nanotime"), function(e1, e2) { stop(paste0("binary '+' is not defined for 'nanoperiod' and 'nanotime' objects; instead use 'plus(e1, e2, tz)'")) }) ##' @rdname nanoperiod setMethod("+", c("nanoival", "nanoperiod"), function(e1, e2) { stop(paste0("binary '+' is not defined for 'nanoival' and 'nanoperiod' objects; instead use 'plus(e1, e2, tz)'")) }) ##' @rdname nanoperiod setMethod("+", c("nanoperiod", "nanoival"), function(e1, e2) { stop(paste0("binary '+' is not defined for 'nanoperiod' and 'nanoival' objects; instead use 'plus(e1, e2, tz)'")) }) ##' @rdname nanoperiod setMethod("+", c("nanotime", "nanoperiod"), function(e1, e2) { stop(paste0("binary '+' is not defined for 'nanotime' and 'nanoperiod' objects; instead use 'plus(e1, e2, tz)'")) }) ##' @rdname nanoperiod setMethod("+", c("nanoperiod", "numeric"), function(e1, e2) { plus_period_integer64_impl(e1, as.integer64(e2)) }) ## -- ##' @rdname nanoperiod setMethod("+", c("nanoduration", "nanoperiod"), function(e1, e2) { plus_period_integer64_impl(e2, e1) }) ##' @rdname nanoperiod setMethod("+", c("integer64", "nanoperiod"), function(e1, e2) { plus_period_integer64_impl(e2, e1) }) ##' @rdname nanoperiod setMethod("+", c("numeric", "nanoperiod"), function(e1, e2) { plus_period_integer64_impl(e2, as.integer64(e1)) }) ## ----------- `*` ##' @noRd setMethod("*", c("ANY", "nanoperiod"), function(e1, e2) { stop("invalid operand types") }) ##' @noRd setMethod("*", c("nanoperiod", "ANY"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoperiod ##' @aliases *,nanoperiod,ANY-method *,ANY,nanoperiod-method setMethod("*", c("nanoperiod", "integer64"), function(e1, e2) { multiplies_period_integer64_impl(e1, e2) }) ##' @rdname nanoperiod setMethod("*", c("nanoperiod", "numeric"), function(e1, e2) { multiplies_period_double_impl(e1, e2) }) ##' @rdname nanoperiod setMethod("*", c("integer64", "nanoperiod"), function(e1, e2) { multiplies_period_integer64_impl(e2, e1) }) ##' @rdname nanoperiod setMethod("*", c("numeric", "nanoperiod"), function(e1, e2) { multiplies_period_double_impl(e2, e1) }) ## ----------- `/` ##' @rdname nanoperiod ##' @noRd setMethod("/", c("ANY", "nanoperiod"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoperiod ##' @noRd setMethod("/", c("nanoperiod", "ANY"), function(e1, e2) { stop("invalid operand types") }) ##' @rdname nanoperiod setMethod("/", c("nanoperiod", "integer64"), function(e1, e2) { divides_period_integer64_impl(e1, e2) }) ##' @rdname nanoperiod setMethod("/", c("nanoperiod", "numeric"), function(e1, e2) { divides_period_double_impl(e1, e2) }) ## Compare ## ------- ##' @noRd setMethod("Compare", c("ANY", "nanoperiod"), function(e1, e2) { stop("operation not defined for 'nanoperiod' objects") }) ##' @noRd setMethod("Compare", c("nanoperiod", "ANY"), function(e1, e2) { stop("operation not defined for 'nanoperiod' objects") }) ##' @rdname nanoperiod setMethod("==", c("nanoperiod", "nanoperiod"), function(e1, e2) eq_period_period_impl(e1, e2)) ##' @rdname nanoperiod setMethod("!=", c("nanoperiod", "nanoperiod"), function(e1, e2) ne_period_period_impl(e1, e2)) ## ---------- plus/minus ops with nanotime and nanoperiod (which require 'tz') ##' @noRd setGeneric("plus", function(e1, e2, tz) standardGeneric("plus")) ##' @noRd setGeneric("minus", function(e1, e2, tz) standardGeneric("minus")) ##' @rdname nanoperiod ##' @aliases plus setMethod("plus", c("nanotime", "nanoperiod", "character"), function(e1, e2, tz) { plus_nanotime_period_impl(e1, e2, tz) }) ##' @rdname nanoperiod setMethod("plus", c("nanoperiod", "nanotime", "character"), function(e1, e2, tz) { plus_nanotime_period_impl(e2, e1, tz) }) ##' @rdname nanoperiod ##' @aliases minus setMethod("minus", c("nanotime", "nanoperiod", "character"), function(e1, e2, tz) { minus_nanotime_period_impl(e1, e2, tz) }) ##' @rdname nanoperiod setMethod("minus", c("nanoperiod", "nanotime", "character"), function(e1, e2, tz) { stop("operation not defined for 'nanoperiod' objects") }) ## ---------- plus/minus ops with nanoival and nanoperiod (which require 'tz') ##' @rdname nanoperiod setMethod("plus", c("nanoival", "nanoperiod", "character"), function(e1, e2, tz) { plus_nanoival_period_impl(e1, e2, tz) }) ##' @rdname nanoperiod setMethod("plus", c("nanoperiod", "nanoival", "character"), function(e1, e2, tz) { plus_nanoival_period_impl(e2, e1, tz) }) ##' @rdname nanoperiod setMethod("minus", c("nanoival", "nanoperiod", "character"), function(e1, e2, tz) { minus_nanoival_period_impl(e1, e2, tz) }) ##' @rdname nanoperiod ##' @noRd setMethod("minus", c("nanoperiod", "nanoival", "character"), function(e1, e2, tz) { stop("operation not defined for 'nanoperiod' objects") }) ##' Test if Two Objects are (Nearly) Equal ##' ##' Compare \code{target} and \code{current} testing \sQuote{near ##' equality}. If they are different, comparison is still made to ##' some extent, and a report of the differences is returned. Do not ##' use \code{all.equal} directly in \code{if} expressions---either ##' use \code{isTRUE(all.equal(....))} or \code{\link{identical}} if ##' appropriate. ##' ##' @param target,current \code{nanoperiod} arguments to be compared ##' @param ... further arguments for different methods ##' @param check.attributes logical indicating if the ##' \code{attributes} of \code{target} and \code{current} (other than ##' the names) should be compared. ##' ##' @seealso \code{\link{identical}}, \code{\link{isTRUE}}, ##' \code{\link{==}}, and \code{\link{all}} for exact equality ##' testing. ##' ##' @method all.equal nanoperiod ##' all.equal.nanoperiod <- function(target, current, ..., check.attributes = TRUE) all.equal.raw(target, current, ..., check.attributes) ##' @rdname all.equal.nanoperiod setMethod("all.equal", c(target = "nanoperiod", current="ANY"), all.equal.nanoperiod) ##' @rdname nanoperiod NA_nanoperiod_ <- new("nanoperiod", complex(1, -1.0609978954826362e-314, 0)) ##' @rdname rounding ##' @param origin a \code{nanotime} scalar indicating the origin at which the rounding is considered ##' @param tz a \code{character} scalar indicating the time zone in which to conduct the rounding setMethod("nano_ceiling", c(x="nanotime", precision="nanoperiod"), function(x, precision, origin=nanotime(), tz) { if (!inherits(origin, "nanotime")) { stop("'origin' must be of class 'nanotime'") } if (!is.character(tz)) { stop("'tz' must be of type 'character'") } if (is.unsorted(x)) { stop("'x' must be sorted") } ceiling_tz_impl(x, precision, origin, tz) }) ##' @rdname rounding setMethod("nano_floor", c(x="nanotime", precision="nanoperiod"), function(x, precision, origin=nanotime(), tz) { if (!inherits(origin, "nanotime")) { stop("'origin' must be of class 'nanotime'") } if (!is.character(tz)) { stop("'tz' must be of type 'character'") } if (is.unsorted(x)) { stop("'x' must be sorted") } floor_tz_impl(x, precision, origin, tz) }) ##' Replicate Elements ##' ##' Replicates the values in 'x' similarly to the default method. ##' ##' @param x a vector of \code{nanoperiod} ##' @param ... further arguments: ##' ##' 'times' an integer-valued vector giving the (non-negative) ##' number of times to repeat each element if of length ##' 'length(x)', or to repeat the whole vector if of length ##' 1. Negative or 'NA' values are an error. A 'double' ##' vector is accepted, other inputs being coerced to an ##' integer or double vector. ##' ##' 'length.out' non-negative integer. The desired length of the ##' output vector. Other inputs will be coerced to a double ##' vector and the first element taken. Ignored if 'NA' or ##' invalid. ##' ##' 'each' non-negative integer. Each element of 'x' is repeated ##' 'each' times. Other inputs will be coerced to an integer ##' or double vector and the first element taken. Treated as ##' '1' if 'NA' or invalid. setMethod("rep", c(x = "nanoperiod"), function(x, ...) { new("nanoperiod", callNextMethod()) }) nanotime/MD50000644000176200001440000000760714325434233012411 0ustar liggesusers7077246d098727fa5679405e000bffd1 *ChangeLog 8bf36dd1fe9b8451e4100c3668c5bc33 *DESCRIPTION 13b69ea4df4fda6eda80d499fee574a8 *NAMESPACE d0e5f558664e47ad9849a0a8c0917c4f *R/RcppExports.R 1bcfbc23362e282ced91d482fe8d3db0 *R/nanoduration.R 40fd54cb15c037aa4439f4e0ed572363 *R/nanoival.R bf48ab606ed0227756fc5fe0294ea7a3 *R/nanoperiod.R dd57cbf116a6c4b9ff96226cc50bcf70 *R/nanotime.R 15f30401c69222a849bb4e75012d0130 *README.md f08b0d3ad494fb9017b5a52e3cdab480 *build/vignette.rds 5e2d19193e19de97094be5c8e1475da1 *cleanup e891df765a0a3b337fe656e18bd2ac5f *demo/00Index 96a72e2a6d51ab7ddf927a6b57e03463 *demo/ggplot2Example.R 524ee00e164d537a07a28be1f0cfb8ee *demo/nanosecondDelayExample.R 2e96eee49cb70901327a92fbde64020c *inst/NEWS.Rd f6411e74660ca98c5c9c0f6a3684cf21 *inst/doc/nanotime-introduction.Rnw 6b4c64a4b8811170b7be6167459785d9 *inst/doc/nanotime-introduction.pdf adef692683d6f7ce9ffee8b6865d25ec *inst/include/nanotime/duration.hpp a9a428be2c0d0c284a7bc45639e3b6a0 *inst/include/nanotime/globals.hpp 70ff665fe75f9471a41ca39926b6caa1 *inst/include/nanotime/interval.hpp eadfcb8abcd3e7ff57c463882c61d32b *inst/include/nanotime/period.hpp a13eea50f9badce56334241a50681f1c *inst/include/nanotime/pseudovector.hpp 6c66b1ce77155b30762a0d8dac630bdd *inst/include/nanotime/utilities.hpp 2ad49f5aaf90657b593f9e2762025a13 *inst/tinytest/test_data.frame.R 40a0ec652117210b75f2615b69e5b69d *inst/tinytest/test_data.table.R 1583220aea87fc2bcaac21d0c2c11ca7 *inst/tinytest/test_nanoduration.R 5ea87d640a31b8a0e83024330208d1d4 *inst/tinytest/test_nanoival.R f253c2790b8ba8b24ed75c930dc13eb5 *inst/tinytest/test_nanoperiod.R f04c5c10243d72ed18c5b49167d1aeec *inst/tinytest/test_nanotime.R c0e44816ea79a16af48d3568a1a763c9 *inst/tinytest/test_ops.R 985688e5b84e698baddf7b7e013194ea *inst/tinytest/test_xts.R f6cd938c98e7b474d93498354a8c987d *inst/tinytest/test_zoo.R c881528535bf44cd672760b9d3e11fa3 *man/all.equal.nanoduration.Rd cd85072a1633e78678f5e7c0ef08e6b0 *man/all.equal.nanoival.Rd 092f3c40f2ec232f0ff633199b1dced4 *man/all.equal.nanoperiod.Rd 67ea3efd6fff04887004caf3ae3b07ea *man/all.equal.nanotime.Rd df466ea394744f11ed3323d2102279d5 *man/is.unsorted-nanoival-method.Rd 4e1ca21fcf9d2ebd6097a55a2d99d3e6 *man/nano_year.Rd ec0df853748b4efd818d49862c1aeb64 *man/nanoduration.Rd 2a3cad0702180a6ae5d227ce57d24ece *man/nanoival.Rd 6b67e5a1d7eca7315e87b4edcd248a6c *man/nanoperiod.Rd b88194e5cc07668fdcdae537f94fdb6b *man/nanoperiod.month.Rd ea081f4696b7abda76125a0e1274ec02 *man/nanotime.Rd 784605b1b089aee1c9bc078683bed7d3 *man/rep-nanoduration-method.Rd 9608e24a432294bc0623ce608305b44f *man/rep-nanoival-method.Rd 537777f3c7e989dbe97f8def8717710a *man/rep-nanoperiod-method.Rd 78612f4ed57aa6c9eca664cf2cc4d1c8 *man/rep-nanotime-method.Rd 89f650bf096d03511cad102b051c8b57 *man/rounding.Rd 91b842a9b6b872593dd936ae6601d42b *man/seq-nanoival-method.Rd dc0abaddeca76a45f2c7bfecc8f4b89b *man/seq.nanoduration.Rd 85133c918e850455542a54660f211c6d *man/seq.nanotime.Rd 78f5cf6b044e00166c73e165e82d20d5 *man/set_operations.Rd 28ff2a81b9f145882a904c265ca8b56d *man/sort-nanoival-method.Rd 4a5cfbe0ef328b4a4e142e74dae49074 *src/Makevars 7b9ece8073039677486a297b6597df26 *src/Makevars.ucrt 67e3a08dca4e44a66ce0cf2130e96946 *src/Makevars.win 802357aec14ee107e79036ad7546eb8a *src/RcppExports.cpp 335131307ca491c6a7fd435f65028f16 *src/duration.cpp b00194feaa12a82aba6b46642795971a *src/interval.cpp dc36c0c1a7b65733dcbd75e3d2d58493 *src/nanotime.cpp 03717c954e6a1c19a38b6c547524ce00 *src/period.cpp ed8fe9cef2698c95c4109862a5a02e37 *src/rounding.cpp 4ce68f543c2378a92e4940c057e825fe *src/strnlen.cpp 22fdad0781464eb37925e754e70a041a *tests/POSIXt.R e958ebec4bc936256837695de174e3da *tests/data.frame.R 39812f967c49889aa0d9c9b75a5f15bb *tests/simpleTests.R 2b1891b86303f721d20555599d42b0af *tests/tinytest.R 988d5f8134b41899d48aa1c6ae939042 *tests/zooTests.R dff1a3abb31a8ca44c16fdbfa9c85da4 *vignettes/nanotime-intro.pdf f6411e74660ca98c5c9c0f6a3684cf21 *vignettes/nanotime-introduction.Rnw nanotime/inst/0000755000176200001440000000000014325355664013056 5ustar liggesusersnanotime/inst/doc/0000755000176200001440000000000014325355664013623 5ustar liggesusersnanotime/inst/doc/nanotime-introduction.pdf0000644000176200001440000024645114325355664020663 0ustar liggesusers%PDF-1.5 %ż÷˘ţ 1 0 obj << /Type /ObjStm /Length 2999 /Filter /FlateDecode /N 53 /First 431 >> stream xśŐ[YsŰ8~ß_·ÉTĘÁ ’[S©ň;‰-DZťŘÉTh‰¶ą‘EG¤2ÉüúíHЇ(Q’łGŃAh\Ý_€aD͉"ÜDż†(ΉG<)O8cś„k?Śđ đd OÁS)|÷‰a>|Q)1&D@sÜwA<"$ń™„ďŠř M|ODáCă$šAoI <řŔč #AŔ‘»Ť čă@ ţ8, F ¤}"ˇ;LAʱL+(a8jĎz8äzˇ`ŕś«f@™KĎ'PsQ@™šĘ‚a ,”‚28UÚ@ ,ŚY@YxĐo>…Eŕ"Ŕ™Ę’Ů©ĂL‡ĘÖçüAč ĘÂQ…DkXĽsBĎ»(…´/—?#B÷!śÜ‘—/m•ýifq29ł<;ř§`BŔlH#ü¦cě·ßórÉ”<»Ś®áuŚVŐ8›&ŁŮ0‚*Gg'äč>Iłt8Ť3ĽĐúű˝ěB2›ŔGBŹăQJţ$®ď°Žř€ĺ˛é.Oş<ĺň”ËSîă—b něe“,šd)ŃĆMĆ Ĺá^ňÚcp`W¦ó Ö›BÉbŇÎŁ4™M‡@ Éä47ąÓdxe@žBłŃŹ Ľ|YíAŃ˝0ŤlmzyµwônđüdpNRÎvö’ńĐW“a2Š'w„^Ĺ“ÝIĎ?ĆÓ4Űż§Dű® ‘›IX7hzćE8Č ˝Ýd¶Ř^tÇ5ʞ{śfÉŚzqyvŽ·ą4Ȣ6ŔÄřÔś»ďÚµ†Oßx._»<Ŕ(Háú˘đ©łói'p7â˛@!?ľŽâ»ű⎠ńŚîŇŢĐ!&ădBG4˘÷4¦cú@'4ˇŹtJSšŃżčOŕOśD¤¸#†É‡w)b‚ť¦˝‚3l¦3… }q™‡ń8`Ěgżś†Q×Âľq‹‡»“»qč NSXU» €Qđĺ"‹>"*Tש˛Âô:«ňt››N>]]ďź|ú E^qK™J=L{ŐQłŤ…j7…Č䬑{­Ń>= Żč!=˘oč[zBô=Łçô‚^ŇôSMȆÉĂChEÍŁŃd¦÷ô–ŢĆđ÷=˘·€źôńţçă}4yüýšËä$žD ü>ŇGŢqt›ąÔÔ’{ڦq2˘ß¬č¦Ńw Ć?h:ĆF2šÝOŁf%tFż`˙ ?éßôďhšÔ$4o.á¦&ŕ;ËôAŹă,Ô%ÜoJx—°-•qXĹBĆőJ× ü[2~ýáxďŐńs\ˇ,šî]îś'á¤"ă*hĘx[QpŢrĐŘ=…\{AÁLžZ›}Ť˘#ŔRT`Áŕ]Š7ĚĽ°‚Ř[¸ˇŢsęě0ZĂtŁą¨=4Ž<‹×šrhˇ6±Bë,°I=‰B†m•Ó\-°Ú˘Đ+ßŘ{ŢŽB3Đ^ĐŞÂz­Y_ÔˇuŁ,¨ hEĂHŃdö~÷m –ś–(î¨ëđAăYao=¤ Ör4Ťżö<+¬Ëřˇ…»!^üú 'ĐvX-B&UG¦†zß«`Ók‹NÇźNkuEŻĄ>N…Ł8šFiś:Ä‚Ő7‡´|Ö ¬,[bŮCËĆŰĂŽskßfIŤnƶ`ńâĘÚ·ůw÷ŃÁŕCěz>ÄŢP\šCˇŞC!˘ÍµĽ_ĂbJ0ěBĄ­Á°…ÇgG{Goް{ÝÍŞ6#+mŤđď „Ië9ŽĚÍí«Ť ť˘ĽŁâ([sîEćľ[úĚ•ChňزąŃS”«š=A­áS5řÜŞ&JµoeŰ…óń‰mVÇáćĂćµ3ľ,ĹüFL]oĆ+ł¬ÍZ5˙łWŃ»EŢÎ*Cm9ľ/ńŁ…Ä& Ţ„Ó(.łç˘ołpĽŽU7™=ÜDÓ4ľ›ô2đÇłtváŢ"Cp6AËĂd-µ ý ÎłąÚFˇeÂvˇS_ł 'ľ;ÜŰ?:sL’“l˝ŘŘD-HĚŁDĐŐŻ°°}łî~·sV•d-zŐ·âK›ö˛^tÝýJ-®ŐHZ@BŞľ±‚xÂ× L”ĺéăkŃ´*P(Nă(MËčEĂxp"ă$Ł" -ţ˙١˙Ąj;Đ„ŁŮ¸HX…ëy“ë»x±o¸ŮqE¸ĚĂ–ĽÝ=||×ôŔ°ŃŞ9 Čjs 8˙•Gq‰2"±ymwÍc«Ď޸ëŚZ°Î+•xKť˘VŐ™}­ČĘi)%…˛ çÎFńľVâxą¸pž3wă{ąüĚĺÖş l^0NÉćËří{ý‡§Ż>|>¨Ř×ëŠ0|+Č"Đě}\n÷»ř2r9ŰëV Íé Î¦lLíyDˇŔ ž»T®MÉtţTćzޱ¬0_ÚRĘ#R;ż˝mEÉDű˛Ęvű`%]ZŰY/g:ĺfŕŘąYł.[:ĆŔ´…Í×ŮL6٬c­—rXŔç`*VrLK‹Ăöw®ŢäŽvË8٧AˇZ͉fډÂ\Ď ¨>7WŐÝĘľn(,j‡u´ŮţÚîçbÚOoŠô5Mę{%B6ĂĽč9 ßС\çaŢ›i8tA›rĆ8&żFYůŇ.Ł3(\zs×a•Ĺłv0%·‡ żˇGÄ¸źŁ ‚‹iGąÜ"ŢXrŐňNqë˝E¤WŰL˘-ćËłOWo*ŕâÚë)ćĘ´ĹĽJáÜôóMíÉ……ř\ť Ş2T†S!¸Š5ĆB0¤Ú˛vJ• 0ŕ§«+ü" ­‰o="Í Ĺ$=Fh)ię ĄaóżÍ…©ĄÂ–q%)Ś—ş21ŁqÉ9klUpÍ]Ď“¶uvÓMvë\öľv ďrLçěëĐb·wŻĎďçlľ·-R*Űy©MŹń©”Ę"ż´­HęĽWďEWąőUH_…U˙ş™ş8)UDˇ~…&x˘@Ňş:Ŕj€ţ—˘ íJ8mĂżiĘc—\TĹq‡«%řĎV ĚőśăA'׉s.ń/s÷uŰcAKve÷°Los¬eteás«Ç[ĆŃ‹,ĺČc‹7o\Čłtj@çµb.ťÓŃÓCÇhkpëä® G©€ČUŕć©íąë—[źAVĽ×€őöŢîďűGçç—Í}żćVD±q˛L˘TŰĂé»!ĘXż;P$X|¤ŠŐ~›ľx×á–—uŰđŐc¬ă¤äüŚd}ŻÄčq\€myX`ómôâĽăi%ö± Wvď¬Ëq»`|ľM‘ű*M·d቞uNđĚ7®=ÖŽ9ű$ŔAsßÚků#Ëř·î“Č%A0`W…žeđä ·ŠŹâ­B‹í=ĺoŹ•A.é(˘Ę?ä ľ˝Ť ء?ńlçíÉ‚mádÎLÖC-ąlţż%©MÚs = ­˙×îÎm_ßË;ŞúÄendstream endobj 55 0 obj << /Subtype /XML /Type /Metadata /Length 1167 >> stream 2022-10-23T19:26:28-05:00 2022-10-23T19:26:28-05:00 TeX Untitled endstream endobj 56 0 obj << /Filter /FlateDecode /Length 5986 >> stream xśµ<ŰŽÜFvŔ>DĂya'Šuc˝Čví]ČđÚYkśM -N7gšëîf›dŹ,c˙"AňůśKU±Řš‹<#É‚ŐlVť:uîçÔ©ţiQäbQŕţßŐî¬Č‹JKĺ|©¬4¦‚Ą3FŰE}öÓ™  ˙Ďj·řÝĹŮóďíBŠĽ’N,.®ÎX‘[U™…U^*˝¸Řť˝Îöőľ—ç°Ž*…Ó&k—đŮ!„Ívé‹ć‹ĺąv.Ż´Í^,ĎUYćU)˛uí§›RZ—5ł'¦ Ŕ Ŕü0`ňŞ2Ů6“Žż\*x(ŚĘúz©DÖżĂ9żĘŢâ8í*çd@¸,ťÎÂN¬2Űx$a Üĺ0[Őí×Ëż^|}&JŞĹĹ7g˙ô:;ŕŞUĄłľYµ8Ł2R.î˘Q·'0_]śýůŚ™p_Ş……ŐD!oăKiU.”dľ|Ůö?.ĎŐĽŮW륀…RŮşŮ^.•.;6ăŘliýçß €”ăĆv©óŞĐjˇr Ô€ŻÖg™X^üí“»J¸Ĺy2îuVi`iVeß4ÝľîyE]eëÎ#%TöŞÝŢ4ĂŘ··!ŕL.•3$#ătnťVž SćZV‹sasFkÂU¨E™‹˛°ň'ç2Ň2˛_6Ŕď\‚•+łq×ěGŹ˝-łî*ě¤Ě^ŤőŘc»–Čă”ΞŃn˛öíÍR‚÷C;ľó;,T2Űf/·Űvßµ0×Ŕ;Ż0·ż¬÷őůď7őîP·× •96Ű? “Möň›g™6űáŐ‹ßN$KH!‹2·@€d‘fďLÁśż«·c»ëú†QTĹ?}ą,‘< ŇŻ^¤R{·ŔÎ×M$ÖčJ.J] č˛Ä^l€8~Ç2zŤK ”Äo_€î"ő­0YƵVÝîĐn›u/‘MslöőR‚üK-˛ăöÝJЄÞ…'+Šxˇ‹ŠĚę-ŚQZ˝ŔŠ:k^°BRf˛íRáś(ł]x%ËěPŻhyĐřěÇš5Qg×ËsŇÂ‚Ś™TšĆľÉşć Ő xb"¶ÄĚ´E‰(o‚ú’ô đ›Ń^%x«éż Uś%Ř€(d>}ŁL‹JAKŘŐýW# TŐ éŢ,‘" ŤDvč™rZfY6 âsÓ®›©†ę^O<]u›¦g«‚/ÁČ Í8˝&#AłT66»C××[ż–sŮřîŔ`ńQÎ0›®ŽűŐş1L¨˝mÇMX‡…r`WĹ#@QčPŁr0zě!$#żevĹĆşÔY·Ýv¬l #oω˙çÂI6`ňA’ŞR Ö…vň,5xKWEś5*b™Ő}ŢM´“:ĐĚ Ňn á’h7uvčZ"€íŢĎ# Ş!Í©4Ő×H"ĚhŔŽ“|%ÚĎ"˘&ˇ˘A˝ŢnÚŐ§—e…žń‚PĄŽĐ@hŚ\¶©ÉJ@±ńßJ€Hř¸¬;43°7ý4omk˙<î0˘ł!k`e6>oöë7KÚrvŢôm—ŚC‚D+člsÜŐűé±o€—V=˛ÄM– ÇX•KI™’k8®Č€Üđr(dQý.×L ¦ôÝҢHXťBŘuűqóŚ„‚EÁ„¨W9íJ ŢI­*®ÉÖÇ&?'$Ň %Q+A úî VłH* T»:nÉO#Rb7%ü¦¤m“ńkŻař&* FÖ=¨Č®€0`d_{M˘ď 4żŮ7kŹ đ )ĆŹ »‡¶”äť¶‹”!"ň+4›í6Ad»+Ć„îU˝…€i›:îKün'xAĺë-aFöjŻuä ˛c쵂hşęzĐ˙qKb- ŔyçßÁÇ Đi‹H ý1řŢ´îW¨Ęř9†U ^7 ~.ÎëöęjtĎ[;^3Č ú˙Ňí›9®őd{řĄČöMĐ··LNâ}4Š"^ÜF1»¬IßÂHâÁ1Ů÷ať]Ć]ŰíxŢŇ(1‡«Ľ1eP¤ô ČÝ\ýfŐN{Úµ»Ă¶Ů]$Yp$6ő~bBGˇ0(`;Ö—hЬ»¸őŻ0–đŘ”lS*T2;q™D Ç­rZ0Öč˛ Šý µŞó«ľňÇČ=z; Ş ˘ç‡"š(Îŕń7Ćş ˝}^wů73ŕó-@e•Kˇx ÇM·b^ÎHçľ&'ZŁęíĐybH˛D#ŕ+2˝ST™·qL}×®šŔ ŠˇĹÄtÔIÖEf ÄÝŔB°ö·‘WH›[Ł=ę˙úÝ«—˙z{ ć"WZ–ó˝‡ÖnסÍâ…M¶i&ôßb ÷śóşÎžWâ’ňÄó˛G %–,eřÁĹľiÖäLEşT‡°Z;†qön·ĆË첣Đ"⏠`&{ič¶GďŚü"°ÇöoMň" ĂoŤÁ¸Äçö6Ą©t"×"ŇôŰnlâ\6#'~Í4†ă4Řfæ;n=MPw/ă;öq?Ŕ®ű&bm}~lú]Ă~˙ެÂNy\İĂ 10l¨ďä]”QŠ )ut@U0ńżpŽ AD›5ĆkšÂ—<Đď$¤†X˛ŕx­—ň¶áĐ Bľ`íěc¬ďćąĎ‰€xC· O–,ĐŐqX Ś·T`gű]B|nĺ‹8˛ţŐq—*>%®/»#í„(ÖBëCŔ4 =MšH€`lSó4gzT˝«‚/rS }[]Ĺ€Ó0…ĎR_Î } TR(ŔřwÚHę˝â7äe>,} ČnJg/tCĺ„›VJ.tş,·)HGĐü·üWä'`ǡď(âÁnľ oaď°JVʉ%n˛´éĘ'FüN¤Ą”ąSnŽ40úÇúşńëGűĺůěčW¶ě 9Ý 1`9öDîjŠÂyl*ex° őń,¬K}~IŢWP^7=†&ĘjňĂ/"Í* Âz›z°ÝwㄹŃNćeë¤äUOMŹËŰ’Ť1/ďTśD=»—%cÓeîcDЎ,\cŘ7Ű–¤Ä_;Ńdţ&yx/Ý,]X•Ů÷)8E7$1çܤ–ŔŔ̲đuPHP»·Ųżâ¬…ÖćgJméÜä{Ä®ěT)ݏć1U­ÎgeĹ ČB´qaEç D4;D4b˛źŰ]0ľ´°ĽŢ_‡G°áÓâUö®©ű˛P® ŕ4eŇá ÄÚW?&qT% ­.Aá|ÝëMvOčząÄ]ŃRŰşżnÂ+ţöÝń:5žŚÖQ‰Á§ 4Óâ¶¶í*DËŕŻ}ý2ÂM‹đŘŔ‘EôNÍ $aĽćo,µĂ  7ź4đŇCű0á˘ÝĹ Ępáq!”K"(ŁĐK Ř‡U0žF…ĺ@Šx5O _hb.AÜ·ç~Šéµ ¦ĺ¬~|ÚE‰±%Ë`é]öY?±Z˛Ŕ8ÎzßSBOůsGĎq¨Ď~»c?L€}XZQĽ1Ô»äilæ“&EƸ-€Ő*ňÄ˝SE )rYIa‘ţp)NÁ r¶¨ MD" ЎëUO&iĄyIdľŢv—MÔ@«<ů‘6Ľé™(íÁ>P¶@0đ  ó"`X(x Ĺ4gtWő¶ŮŻë~›nÇłDQšlIŔȲ„'§ŇX“Z×ď&»ř °:ç‹Ńör±uFXEĆ0»&çb%ÉÄş9®läimĄťßŰnĄKNé/˝UqŹ’Ś’· <ě˝E”źÉ.1ÚAž:ô‹áÇücxă%Q¦Ô<áü–Ô Aep:7ܶ‡2Ą6aÁB hśX<űĘ{LŹ!ą˙¤NC! 2mŰ^oĆ0d°ľI˘¶KŮ–w8,Dw94ýMCI< ¶(ęt3ĺC(ܰÔ0=‘˛S˛#2©Âň6Ű â{€M4ĚŢŔś 2˛BŻÚ] î Ô]ŕŮČfÄŕŹî›v»|e˘b˘đ©mWFçÂΩKĆÔěęjh˘C2Ůjîzx–¸ł`u˘R9 Vu´·+L´ĚqŠkŚ7hÇ>J=Źg'7=ÁÎß#˘ď2P­ř¨„Î ¸Î Éô>âY Ňă*iâÇy­¸w%H;×XZy©}sʫșy\ËŐµšë™xWśk×ăŘ·—Ç1­bôëw°PńÇW±L§´’đCM–ĂŮ|Ć齟É!!o>'F‘ I#> ˘bM9ź3EŇn_Đö¨zPMn&hx,_úęLßütlűfď™ON¤|ňĹŽÉ*EsKăĐ®›>D>pĄaľÜé‘Ç>´—ŰRMĹ ”ëi„§?cĚI T­eßď—ÍŞýlľˇćŠÔÓ;–@ÄúGŽ ‚:íBcÉ’ Ăö0+šx|)î4Ž”ÎäFsŞŠń ÎmňąľÄ¦›tƇɛ*/á)™™V&´$} %3:ËU¤ W`Ďý€jV’¤÷L<7–-ć—ŽUŽ»ŇRUT9˛ŕ×oE!Ýl9ߊ? g©§ŢĆRRLř2Âą÷qiĆ˝¸hU­U÷ŕ’ř͑и€đĺÎľŹLt/BĆHjŢIgżYâ®Ě…ă<ÚŢŮ+r±›Ŕ??€´­©¤JŇĚí(l„1`ĺ¬ŮPŽ&Á7x.•ďqjĘŔý‹X¬ćbhšťŚ^ŘöžžصźVřgo$9 ÁÖ#ˇLá+7Đvń-žmĚęü!UCcörś¦Ĺ 9_wwâĐ#»J‘—ŇG>«M74\ÜŔʦçŽJh¬u®”Šç^_wkrۆ0ç«Úă]ôqb>ŰTe8±ţ?µîv#4ř>áŇÝdżď¶Í%Xš}ó¨â_ ›+Ő ňÓ땸,D.Őú·‹Ý T‚Č©jÎZî€)Řé>‚H l¬f˛íń˛o±Řu˛mp@óĄ'—@rňqŠŐaAEŤd'›ýcĽßÉřTÜY‡TŐż,±B°úqSďánÓz¦fóňi¤C„+OĄCŔn¬Ű˝ŻëäP•Nö9đż??QX‘-S°v”¤RŐˇĐhŔ űW}·ó¸›`¤6ąĹ-ÁäľÖ‚€–ܵs<’ÖC^㣴„%±gŐॠŐ§7Dče ú5'ÄGh.ŕ^U*˙ř悵RŔ9çűJ=Ő˝H*ŐLaĂw‰ŘşxöO®Đź4řaľXçăá!YŔ‹UÓN”FT@6á±JËǤ§ÁAş*Qúp ľÚý*”ĆŞżŽö_͡[mţ›ť?(t¤y˘˛Ĺy!ŕo¤ł.~ź—˝¸żđĎÉ2Ĺü“7­L•«RžlÚŰLFOPe<9 e}ľ“WÇ<1ŻFű©ătŽë¤ŻcúC»Ż·tĘ&IšbÎŕEůöň‘›Ć}Žáq´Üö¬čD¤ťšT±®Ë:ĎŤ9ół@jě©<ŇĘqlß\5}Xjě&1݇ŰjUďŃÖ€”)OŰŚŤwU¬\^bs¨żGĐß’Ć p˘NęĆţđm„ë÷uG%Lë˛ “f<<ň‡ľ÷1"t9>g„¸}`Bľă;d„ĽĆ2Ęńđ”d=›žţéEżŰâ]ělČ6ĘÇgxGĆŠrN_2掦p'3ÂŰű_’¦*)ýµšm3˝ťő:íĽMf>ŽýˇŁFîĎ7č©Í¬sĺödđvŞ ÷bîńuXU2]ęذ1cv^}qć^‡±?®’®›2kZě °«?ßßî(,Ö;}ÉçŢhłĐĽk?áy˛Ň­ iŞˇ„JójSă핦żm!‹Y¤×Äě‹(??ťHú ˛Š[›MAw€ĆŤ.Ő˘oYěńŘÁ겨@ŢžqvĺAŰś~Ľ"ÔEn`d¦0ŢC¦čĚęĹ[XŁXŕţřŢ»ř iP)ąŘžř“kqË7aÖöěi `ý0–Äd?YnÝ«Źć6Źl0ÍDőÁ2€µ¤ő§Ňř ^Ţ‘hŘJÍ ĎĚČÇŰ„›ęt3A}ě. ĺ+€·wîB đ¦„<č\@!ľow,á+^UK—ú\W@Ŕ_$>ÂvTtŮLÖŕ¬ĹHľ1źŻeĘ«2x…ÂG›+čÓ}»»_Đ —‹Đ*ůŹx×ÚŮkń×€˙†&˛ş(ĚE˙™ţźböń5 *sđ!ęh@ ůSÉi€K—zť}>QŇSâZˇľ™qřŽ /v ¶]=˙¶yűź˙Ńő?~ţaQĢ–ľ,í|÷Ëd÷ź@¸ !•r&\ÂťRâ}1űŔPç®(ń=€ą,ĽŞmĆń0|ńü9^Ćźňxĺ/ďϗ玮TˇkĎ»ţúy¸ş& ĽşvÝüK”Ç'üdŠĆĐn†ŃT,ĺXe˙/; L!żÇź4I€–&—â›p¦Ě·˙$d|1\Ú,üJŠšýJŠH%eŽ(D:ÖşŕŐ˙nĹ&#\n`@EÄ˙<â÷?nc•Ĺ B•&›s˙|ö˙ĚŻ—Sendstream endobj 57 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1969 >> stream xśŤU Pgß5°Y-Çő[ऻi;çăTN´­o[P<Ąµ"ʇ$ÁáH‚!$ů/!$„đň塜DŠ ľm§^[˝Îe†ŃóÎ«Ż©g§Ží]ű-ó9ő6"ťcîćz;ł;óí·ó˙˙ţżď÷ű-IřM#H’ |wSĽ"ż8bŃÂ(Mn–ďÍla)„M^–VŚŹŚÇřC€ü.…MW!ă/PęĎц InËĘ]«)(+ĘQŞ´ňĹ‹-Y¸P|.—g”ÉŁÂĺ1ŠLµFW¬Î‘+ňłä1á›ÂĺďitâËů\MľĆˇB靏†ÎŹş´I,ĺC“[Âţşç%űÄňj&ZQ –­ĽŤ—â•kă7đŇŰQ(EÜń˘e,s3«`‘p˙ću¸÷="`Éjv)Ž,EďxŃ­ä±XśŻŘATÎś´oŚÝZśŁd*]9lös¦‚Ü$=•| Z€F*@ g9fa2ĎÄţÚ2gc[Ü.˛ľźFFi“ëhç0ĐßđxF:ř”Ô.YüŠ}C%H8fDzeš(&RXëg䨧’3đĽoŚţyđ“úý|@·Č:ŮÝG¤Ü˙9đ˝ńH"ČŃ+ \Î;VÖ–éQ5(ś ®L' ŇCGť×u¶ă@_lŰË©¤*ÜjÁs˘/GŢís}>Âé&Üđ\ 8ě;&|žă_#ÎŃË?—¶Řýž•č¦*{PŽ]žśj¨fQĄô­“â~8)îv8üŕéäsĐ&J;çą´­L$,Ŕ~Š˘®=‹ZĄÍî#ť§~ ży[ô¤+ľĆt¤GŘ(ň„µLOěeK¨r( ­Ů´š6ĐVĘt&ăÁŽŻ4ź[“.¤*‹ °Öf¬3qhË“×÷•šőfChŐ®=i‰° ´-z‡ÉfáÍ@›ö™«ö5¬·ŐrŤU-m€^„3h†ó}´Tȱ7CŘ}6xp×gŃÎľSĎ2ĐT{ÚŇLŰ,.C­ vOEJĆr _ÇźţĹţ·o>ë)ĎópnýˇŃXżÇů»Ž+_ µbřë ±I›Ťj eďb¨şgţ”F]TgŠĂ#‹ĹY”,÷ŠíŕŘťY7ˇu‹mőÔ¸÷1đc⯛Lü3ľÄź“ş^SÉZQőß÷“‘˙”xj›04 @Ň ‹h–űHľ‚¶Šm~˘cüĂ”°”-r—ź$MśĂniľ}÷0{Žú a˙‘«ŹÇč&âxëżÜ¨“x$}><Ż\#}#Żž¸%ă#φöŤĽ.a×F%[ţŐ›6ě¤íĘŐęÔĆ ú'˙{÷Ż?3ÚTşŐGÂ˙ą%j!ÂF FI(Ľ‚%(}Ď\—v[ůBv Uhµrk¤…Ľµ›˝Nuó|7‡oúýŻíŔ’!­ĺôÚxĘ;…˝ŔÎl›ůVŔtxᆞ·Őó 6> ŕ‘Ű-®ÄµÍn řAü Ć#xúendstream endobj 58 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 4410 >> stream xśťWyTS×·ľrď!ŠxťĐ$ZęĚ VQFDq™  !(ŕPÄ:´VQ¨(DQP"âÚbDhh«¶ÖjŐÖjQ»oމżőÎM¨¶o˝?ŢzdĺĚ{řöţöľ"ĘĚ„‰Dý•ɱéˇ1)sśgŞUńšo#⇛đ#Ls±Z×®ËóR Y" łŁĂŢ űĚJ7°łżń‘"­č„čw‡…ó;Ž3v–:5+M™¤‘Źwww—ÇfÉ{wäŢŠtebŠÜŽ V)TęÔdEŠĆEŞPČ5I y‚RĄĎš˛4 ŘOîŕĽPî§HQ¤Ĺ¨ä!±*eś|Ž2N‘’®p”'¨Óä*ăD§N‰Wj”ę”tąWş”/5ŽňŁĆSţT5‘šMM˘©ÉÔj DSVÔĘšHqÔ j05„J Łl¨>”9•LYRJMőŁúSÓIŘRfÔ j#ŐN˝…‹ęMÄ&1&»L®›€i¦é#3ąYYşYˇŮ±D\(î h_zý#cĂř0Ŭ)«bËŮg}"űś0w6źgŢŇפŻmß%}‹űž±Y˛¸l9²Řň¶d‚¤Jňs?użý™ţ^ý×öżcef5ÄĘÉĘËj THt H Ö`µ0V+â·=×íĹŕBă]şd1ö qÁŰd18Óç,Ż+ϧźAŤXÂŇň.Đ7E; äňÁÖ ­|5§Ż&ÓnĆş»­ˇîĆŐăËĄřYů}n`ffXęÜ8©µŰw yBbřĢSäŔn›B3–ĂîvX„}°ďKL¸ő€Ľ Đá/Z”€“)ď Ą¬áŁÄŘ“Ć2|;Âm1žJĂf=Y+'†®ün(:Cnč>âWq›[×תN‡Ţ‹‹cń@lŹsđz°ĆöÄş°| SóeŘŽÎu YäBް~Oa"Lţć70żTź•T.+Z˝'3?ž%vá-Ě„>đ+ô}ElËl #ÎÁň·ŰÉü}rnŁúbaĐo ·;w/Č/úźśŤüPxŠr. ćjî›sľŁĂ|}}ÂoĽ|ŮŘŮ%+>¬DÝŕ_ĺ»A ¦¨ëČů–ŻnTü@ŚŔLőǼΰß2lF%űNú—ąfĂ€řŠ'žŚ'…zb±ěhZŢ«)ď@4ťĘ,oYzÜź\4K°űô’éUa˛Ş%Ę6t]8v˘…Ĺ6ÝvďĂQŐo”c¸źĎ?Tý¨ óČĎť¨ű=Q˛ ?Á ˙ îĽ%XéżMćëČżŚ–đCI< ™1ž[Wż‹ĄZĆ:äŢéÓ÷öďÝľµX ŁŤy›ŃBc’g˛ÖăŢ0†`„s˝˘n ˘4‚¨o‰¨oÉÚü·ÉŕDÄ4iŔ^‰¨‘<˝@°voÂmzb'¶%ÖŽâ‹M÷©ŠWÉŠ3ä^ʆ©‹‡śĘ)ČAěňřŐłSvdI×îŰ´oÓ1ršţ›˙nč6ú˛¨¶˛¶ňđÔ„ş’Ľaź‹Câ 6ěA%ěńJíůŽéayR‰®Xa Ńu% ż:!üÂůánŔVŕAo‰Ý–±21jÁĘyDËIoĘ㻟őĄ3kSNČeíË.T°0’Î',y†˝É©üţŻĆ+a4ž Kź_?uďŠěŕń#Z4oŕÍŃ}cná¦-–c[_—Nü=Ą!ć׊˛ť{ʤϙuŰ6n߀؄Ü}Ť28×›ś}yO­!~Ł?Ő â«ÉĺÇL`dŚßÜäĘv)ĽŔr˝ű^÷ććůŁWkĄŚ*ŚŮŘ*ŕ Ô%sŘéoß·’4íÁ|µ;ĐX¤—á>ĽLĂ<}µŘĐ@ţĄVt>Exâň„ľŠY’Ľx~zy‡´ ;ÍbĐôËęăęWVw’,rü©†Ëř*’ŮĹFĽn8 2liw˝Ä—±\MF¶4Ś%˛`4ý€·ş«·2J5R‘sa„)č—VúÉ~TÎB&3®`;l7=[ĺJÁ†Ţ}Ąô ‘Ü|4+1+wÍÚŤ˛Ě ůć„n"ĎZĽ9ˇBEYjĹŠs™Ťč*ş|äüE¤Ţąˇp ci< ’9ʏďe)eµu%ÚŻ ¤ŤůŐ»?ŰQ´gč{'”qŕ ‡›„]'‚«0o|űă21xŇż‚çcě)Ś hőÇä7I+jéÍăâ8âyůećä˘siŰpϡ¸Ţ̸•xI–Đp2ůŁđ4ĺB 0ǸÎó>öŽa>ľŢËnô<7¤1I-Â8wµ˘,˛{áä·Y,@ŠŐ=şţÄßRÝĚô#p_~„»Đˇoog¶2Kńa9óveIG1‡¶l?€NˇşÝ‡÷~Qt ´´ ŇtÖCţáţ“B¤Ăcn ™ř=¶!ń=Ůy$ž}ź|“`đă»ŔĘđ0:ËGťş±ŢŃmŻ/îm?RP´}[ô5łrGR^&b]"ŁĆÉfOwąŁ÷9ďź1”vř„°Ąš0űB {0WA!siöŕ8€ťŰx,)ôôxÎŚś•3?T'ÍđJHšj,rŹ^qâ ÖĂPS~,AÖŤ‰i‹("®8[á©Řó!6ˇ­5Ĺ-—d3™Ůa‘>‹’JNçH cäĹĄT%×']ÍľOÉőéM°–ń—ü)~]—fÚ;.ńźŃńüĎłßܽ뎄¸č "»;zÓ‘4G×δ?ś“Q$-ČútJbń}C‹„:˛*TG"÷G"_´T‚–1öi%Ä ó‰HB­!ˇŽt{ůĘŕMhĂöő˛í™( ĺ żO3Š“X|”ÖćîG•[`Ĺ–˝.µ÷*O· _ĐW«›’Ş–źŚ("fëmŚ.›`F^`ęŃÁ-×\›ź†”(i:{íšu«7G#Ö@éü]"ĽCŔ/ÎĐȵ™Ö%›‘8·"#‚”,H°Zŕh†Ń¦ü+ţSu¬=“XÖěqŚ„ žeçŽGań— ŔA-űső‹Ěj5 š0Îv~ýw›Ą¤˝ĘÇăţšÁÄÉ!`úŔËĚ»ŠmŽČ0]"?¤:„š†^>ŞűYSś×.)QŚ40şz˘Y— Y‚Qł´*''9wSŢÎ RlĆ”o=µM‹Řź«ŞĘtmď6`$ ˇĎń/9P’Ná.Ů^©ůwĹX¤Ex<îsü¤0ôa®| ÎŤ—Â/0˘Ĺx"mh- őKÖ áá<ˇ~ĺ2#cśť#ëJů\ěDćČ˝dŢů¨¦đî•ŃCÔ}¤©ńü™’ŻĐ=–Ď}_CŤţH× ––ü—ĺ»¶ű*Ȱڍ2Ăřl}ęę?ÚďŽëUµWĎKŤ–b˝aĺ_s~ó:đ¦üÂɇ·tĺĹ…ÇKYŹ Bq«"°Ś‘-ř}„Z‹Ô8˘K⦣Ů+˘CbdŽCxÂV&śXXçß©¸ŹşQkĹ™«µÍÚ_ A0hÍCĺĺľŐnu±Y:¶ú@ÂçÉ{¦‘ŇčąqęőšdMJ@ęâěŞuÇ7ŢFOŃý=w÷+Ş?~¸–„śŕzä ‚sůuś~áÔĄ.L†ëĚh,!L!¨(T¦, E_€ DĚ›/| 4ŃkJ´Żî@żGUÍč7F8?ÄŽŘ~ň$ě´ mĚˑ°Rúűęłm×j˘˝§Ą©đ8l*Ĺî s>ÁY~ýŢúđ丏ŕÝNH†.î<Ęß~xÓąőÇcŃb6(*28 ±ćć)NçáQO&i!aĚ￀ô~bóÔ/dÖ?]?}´ˇ}OĽŤGxř©ÇIŐIëĂŃöcÄäŐě,Ţ}°°˘˛ř4bŻT*CĽcÝdF+‚ŻŤńçĹűcwň=¦÷cs¨Ćă .ăo1x9°˘!®ű 8 ¦ŻI\“›Ü]§[ĘéűŃsô21  ÷źŞ,®Gě7őK&»E-ń VV|ąU¨;p˙§® %ÚŹ}őŠ0·ířx𲤏U±˛RpĂŮ^§@!iźG“°¨)¨"ý”oŕ>9›[šu$áâě㡉hV|´wŚo¶'ÂÂ’ýӫ柸˙#y{äooŔ†»>Ĺ’yńŮQ˛ť·úěxa[mÍÔ€gŚdq(×^·dÚôAQM·ż;ÓÜ.3¶E_ F• öl!9ú†ŽŽ‚9uPŘč4—LµSHîŚr˛ĹŘî= ¨:ą·¨DVż'żô‹mţžaĘŁu[ĄŹřyÜŤşEnÓ˘Ć]Ľ{ŻöŇ5CŃ;Č;ifHą(;Ňşa;đőŽČ)ÝR-©˙ýL!J {…c)Âλ4b)9ű‚ ±J0C`Ož< ôf{o’ť\•ŕe0ŕŐH"ś¸„“9kOżÁ±'ÉW(¶GŘN‰é‘8š52ď¤'·ÁjÔë?‘84"ŇđżüÉ ˇ[°ľűęq‹ŰÁm‚˝v¶2Č/5)äc6”9˝«|ßŃCµźWŁď+Ă lDpžq¸ Ű@™ĺ÷JÄ7C§oý€oĄ˙ń$,ďC˛ĽŽŻ‹äpě[•¸†XťJ,Ń”ňŐZ¦ /ĄÁÜFöó| ą×Â’˘ţĎż7gendstream endobj 59 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 6001 >> stream xśŤXTT×ÖľăpďęŚÍ ö bŤ…Ä® JS FDŞTÍÁ€‚ Eš(ED¤ZE±ĆQó-*‰&ę‹îKÎüçgňňÖú×°fÁáśs÷ůηżýí+˘´zQ"‘hŕ"/ç€ ÷€…« müýś•ÂŘ~¨Ö‹&ţţÖFŁ~bÔO+gذťRţóA° ¤z‰DŽľ‹ü7‡x{zL™=ŰŘŔ9ĐŔYi RnVąřzzą»űř¸„,ô pwö30Sş,đő5Ь 4ptŘęîfd°Č_éáíć® ňvö5úĎ‚ž)ŠZą@iżĐßaŃ测·, X¸,ČTe¶uy°łů6—!®+·»Y¸[zXyzŮxŻÚ´ÚÇÖ×oÍFă)éS§Mź‘:óóYłçĚ=6eÜř§ý&=—QÔĘ’šMŤ¤¬¨9Ô(ĘššKŤ¦l¨1Ô*j,µšGŮRă);jµ†šHŮS ©I”µ2¤ÖR‹)#Ę‘ZBM¦–RĆÔ2j eJ™QÓ¨ĺÔtĘśšA­ fR+) jµ€DI©]”ŚLq”LéRC(=JźJ ŁJByS˝©>Ô%ĘŹęO]Ł””65€Šˇâ(+rC”Ů䨨żhźč^ݱ˝PŻ?ÄKÄZb-g­ş?M˙Á|Á0<;ug+Řß%A’›˝ŤzÇő>ÝGÚg}ź–ľtß-}›űŤě‡ú=č?_[¬í®ýë€N ”Ü0°vŢ ĹîIÇHĄĄßJ”-‘]”©Ż\Ĺ ĺ,¸:3t”:'u­uătź‘Y;ÄeH§ŢgzŁőöęÖ» ÷A”jwÉP5xÔĂ﹢®1b¨ěšËáŚu$íöŐěňä7a QĚ-Ľ*6|e<®f-ÓqlC;ŚŕŢâŻg´ů+¨‚—•\•ľîď]Y]‰řW0ŽÉŰłhxÂÖäW¦A’;‡ý*đv{¨c<íI&°¶š ĺě/Žg¦o´ň0•·¸ł˛ëXâIűŢÄż“™¶ń´6˙UóŹŹ‹˘ůßĹi]Ó8Wöjá Ľ5‹ AyWł¦{âŔT‚á886Ü4–Śî©f—Ąc;¸ćqy}ote[ŁS#đĽë‚KJú…=ôqV›Ť ¸2jĄď€-?ŰĽŇ•ýZ¦yĐą¸ěpZÝČn·NźÍ—Ďn€ô•iműéĐÉÓwőˇ×Ľ3ŘP.ŰfŚĎq°Ź-LĚŮ˝I WłËś ÖÎxPdJŚPČ~Ĺ7´ —­J*Ű}ü[ÜĽŃxĚJ¬żU•¸;PˇÍWD×đSkD•ťPŇ)†|>’ĂC'ŚÁăń¸WŁAô~ă`Üř7x¨bŁÖw­_`ëX9g®ő=ŕ@ç\űwdŹŽn¬=GhŽĐ¶ń{±ˇáË„C¤\’C3hP±ŕŹÚöw#Ó•ŽMp.6„˘}iç4Čtő‹lâ5‰jŢň:gĹüæ®bUXę­LđGzxć8ĐXö(_U˝˝R±?$Ó> FĚÂł4+$ÁnXA>nX÷*–Ľ·PÔoi żŠ®ˇëéW $Ú|#VVŔ˛:ľ©ę’´ł’žčĘľ+ŔJ"+s C沕qĄ; fă^˝!×l0»÷rr vµS„)î&Śş˝›0˛ďŔb9xĘË/K?Š$ŹĎ/Ĺ,°Ěd| rÚ& J'ů›ŤŇ:>ZíŰ4ëĘÚŻ´đä6«3g? ąŚ,O=@}źváŁÁŚ•µŰ2!¸oTŤ[~ ßNź čˇzţn˝ć߯Š0#WćośAě/čnÚ7§˙u±ć‚ľđŔC`Ţ!źµŽ»Ď€ůSCĽŰMťÍ&$•Š4h4ń# ~€]b~ďĎŮĄ9îq&HÎ7Ť§ăڎ÷‰şô§ŘŽÝľ}EI§ Ö.)$›ć/°hß$Ó=8uoÖu‡_|’Z_‡ sőîۼ„Ř‚ÁmTeő°§^`˝UĂÁłˇgteż•éđéđůfűđPçAĚb2Âö-˘`łłcax8ŤgÁ%Ł´¬:c&ąé1ęŔż[›—IxÔ÷‘]Ůu˘qĚÍeV±ŐŤĺ…e(eÇě•yÄlMÝ–Ś$˛ĘŤbvy*=}Ľ<%ťĄ@V©P;aăŁDµŠę!K»UĂq™$W3‹“·N§Â,–„»„»ĺ?áfŠŮ–9‰ncu+sĺŻ±ŽŠ>ÁO«‘žht}ԕ­†—Ľ7çťé¶wAťY±fši­ĎCw…¬řŞ_EČ}'OokĄJ–ż<ň!íuňÚÓ„ź}®ź{Q^ŁŘtŘ=Ă+["[˝ę°2ŻFż®äpÓÁ±á‡ä)‹é“Śv×ňČ&­†¶&iÍ[Ŕ?ŘśŐ•ńü ř–saoĆ“đ°ëíť $Ďź2h°ÓźŢáńJ!Ĺ2Böš,›Ćĺ,ßgAfmÁr< {bÝ+X”fçĂŻTůó$ÓîH †ÍÎhI¦«YmxĽó4ß»áQ®čI‡ř ?›ĂwŮĹy~Uu{3ä•lP|ĐN™%ew “đ¤wěF#3%íKxż•\Au=¤®ŕĺâÔĘ„jvĄćJňá%Î'Ł+{Fm„Qľ‘# Npe/ +q~ Qdôb·(_Ýqٶ‚×-ÍΕľě®*'a„ ‰ˇ8”±cíťl*¨ą —­‚q¬SrHÍ/ug{¦,vrśě‡FJdeóOÚÝ—ËÂQSţĄň÷Q-ĄKč&$qđ+;yűŇa^EmŇŞˇV Ť´ ŐL7Cbî°° çÓ~0»š]Śá>xŔ×WS n®ěٸ=á8¤Ýá ÓLÂßř¦Í#TÉO¬ĄóaâÝE>‘ÖQŘÖ&†öëJÖfo|úýŹŹŹqŽ%cŢ•¬e  ›`,:»Ź@gęÁ6ĆĄDăÁźnňľú=Ľ*P˙Y,-ÍĘ=ę€]ä6u»‚8<€”ť{¦Ŕ`˙ĎĎ`> ›ű÷ٰ>2ČQe쇥Z|?¶l_ÉÚ/ç–âAXniuâ·ˇD_H6©˙Ň$Ńľ3âĂ:| ,'‹ű Ę»•żČôdČNWöŇźg]!ś5+ońŹ+E_ńűÄ_}ä‰ziŔbĄĂfĄŢÄcŰCŁCP°Ţ¦ĂA'®4¶Ý '~{«@ŽĄ=d„/ă~půONŘÄžçGU>ó_śŕΰÎţ.áDüFšÝ† mk”ťť©ÍfîČŚĎD’ŁůyGZmŹOÄÝĺéXÖÜś}¤EˇÝőľ'ËDÍ|ňq©xV3)!94_ĂÂ6őot ;ş´hu»#ÜLĐ…jvEr¤&Ó3. §ŢäËbu<¶âż˘c/búâö Žł!Ű,c^<˝zRÂuÔý ô´®,ŻN‡×±Ś¬Ýž‰šF@ôa „Nð˘MkĎ ´^I*;ÎUsd‹‹Ń—Ä×Âr±ŇŠ'Nˇ†—uMá°ë»×/Éźčę¤á¤ć|o˘–ĆÜęÓ ŮÚ5‚ÜhÜm×\"7Ú„¬¬¦]ÝÎyyFz"ÉË›ĐÝřîőÁ’¸G $ëz ˇšůĎšĹĹH,5ědůAę+ôUţ5sŕŔó®ě…č!´z‹;ůTş[ ˛t çřÂń#ŁĎĎ ^'Ş|QOĹüęwśŤ»C°’Ś1˝ żFI(IíLbÚ‡öI`Ŕâ;X„ő'ŚÂńŘgă`ČĄ+ąÇ/ȧÂ^‡2{ž;{I®UnŹâP<‰Ř?´‰ďlŐü›7űUĚ÷ęZĚÍ@óý,­M—{MAXD~ĘŤż1k]Őî÷ýŇzö§Ł­ŮWŃ"ĎLŻX¶.(™$¶ZŔ=ĹZŘ[LĹ´`Y§’jfVOˇč(´áq \„4~é€ Żd(9 Xq›Eßçź©É}f9äĐŢĚtPrħpî3sžł% ąyísYM}4-Df<ážĆ Ä˝ř‹=p`‰ŤÜ•C”vĆ«Ç0&Í8W+đ¶żYŮÜdě>€˛ČäÁmk p/ +Ě„©v­$©›‹•ő°ţ›ëUŕŃU%=ţŔúŘ? ¸Ł+Dń4ďĘÉ&R9î©îCqźyË&Ěo°jß®đqőE[PhRŘžp‰ěiÔ˛HWGsýąW×{÷zAM“ĽęH^ ŞDwÖ”â>&fů*í«”ڞ’2÷fěA{ČŻ˛?Hľ˝ö´<şx[±z50äI8'Šk=î4oľ«Łµµkă·íÇë[ä®ę9ÜËG˘­Ţ*K‡©łmë[kK+[˛ĺÚ|Á]ďj·¨ý$TX1 DM`s»šďöŇš6MSX˙©Źs&(‰ńÔL }śéăÖ}´ź ŹŞ ŁŽLá&Â~ůgźÝă š=ť‰žˇŞ-‡gç™'-ot..‹®C¨đë’=’cěN$|ć!źtŐů†ŻZüëËĽóÖîę`óYôÜäž)7^Ç520đ‚űČq6n¸_\FnˇLÓĄfĺľVúH H˛Ł.{ÎgKŔ&źCGŽ*I»î×'?;4™¸Úm/×ţm:qŠp\„~›&†Pťk Ěáká u-ý Óř×2®ÄUF¦…ăţjo<‹?B/ađ ućx—”ŚK)dBqá´6¬ă-ŕ ¨ä‚ßYÇ™[řX"kÉŞRĎ†Š…GÓҢ÷ËÍ™])h/JAő‡O6ť—™ŃČżlUw±ĹPÚ5ŹĂ# Ö[đ–N,‘0˛d°¶‚ŹT8i=?5ŻĹkFOžl˙Ö‚ăé7ωÄ6ˇ]˘\$=Ăeażĺ´3 SŠhu9ąłqôFxr‚ĹTrd&Ý%bµ Ź6rô01xhýÖö{#lsź?uZĘëĽ ŞÓ•=„á÷9ňđĹĐhR Đ&wIQ8mńď‡Ú%ŻżĽ†űáA3LÍ|ňUG˛ö'Ą¦Ë;ŮâÜŇÔr$i?eo2ÇÖqLll"ŠUX±9_H$eF–üÓ™u&SÍ–ű‘ÖrłÂ÷aTŇŽÄh¤ç¨RÚß·‚ľ`DŻĄmDĎĚ/bqŠ€¶G.x^áG Ţ´‹y­.ŇĚuŞgŇËá[Úˇ@_Á4?“ý‹8|#Aş˘ëáŇEXqOôú"D<ż˛»ÍO*Ţ]I´KqÝi”‘੎*()EĄp}´cwLbŇóTů:^_÷f˝} 03ďa}Ďř(78ÁÉ{dß±¶”‚â!ĚŢ‚»Üv¤ ť“śő©pň đ‰LŠLŤ_avÇ Xś6ݵł–ŔNťO§}śvůŻÓ4´‚7ŔłUtęÔ—jٵžĂ»Bń8<áT 6}…E0>űőßä[6őîkeµŐuŤĽ–ľé„é(Qó‘ŕÓř:W]r2łIž75ÜrŢ,CŰďaZĘŰť'đÎ#źWzłÁ‰ß¨+łş) 3—•=l`˛žŃĐĆŕűúŃůŚĚ vékzŐ¦Đ3ü«Fim;‘řvëGş2{¸ĂÓUŮŐˇ«’«gÎ\żÝč0×Îß~Ť·üDw§ŞşŤŚżś“°dŕ¬ůĂUŘ]WĘe…Ć^ë¬Lô1ýx.ŚĹó§ďä2{tom›a™DVG©8Đw¸ć‹L$&«lgL´8˙äZIÍ7D˛›ÖäBf3ĽmŐtBń“á·>Č9Ň I&ٵzť˙ć_Ďš`źď/>¦f9@ť  ÄÍüŕQcÇc9Öů~&ôŻ=µ˙ĐYůĚN†ŤI´áV4IÜ(‰~™¨‰ŠóňßěéU¤,//..ŻP&»ţˇĺĺďďéY´™Ś‘±"/Ryoá/ čĽLD÷?V~sŻÓ®Ý#eü˛_…w€jSHrxZ$!ŚŕňHÝ_č±~a¸D»ëEdÄVÜ*'_ŇŇ0őŘßş˛?ŔŚčÄË/ń¬~ŢłgçŰA†X¶OQČ(~^$§ž÷a}áçwMŁe¨#ąÓĹÖ¤%gý­ÖŘo>,0EçO)ř(űĎŰěň"+¬ţ¶âÂ)ĹG©$ä˙3˙cÂy˝$ ň˙UXŞóqÚ‘O§-˙»ĎŔ#Nteź˝{(ćuş\8ĽT5ODx?I—wx", –őÔ/°)‚H±­Ävđ“•°őˇ¸”¬$˛űY`+Śp,‘DĚő$dpaî; ÁţŃ0/Í'k“’ĐKpŇćovŰúAowž–ţŇ>¤:~·şqĹé٨PRş%ßeřÔ±x:é6PĽÜ<”öýÓÄ{B@kßÓřhFm{jžSr(]ľ‰µŢLc—Ű zsŞ*_"3€)Žś˛ ¨¸¸  ¸(¨@é§R)ĺÚP*POtť\…ż űćż vůoămâŃϰA›żűIg›;ÄĽ[W(7Ú1ˇ$0Ç éý'xĹ˙ţÓćÎŞ!ĺ‡č:ő{¦ÇPWÖ—‹…ÄxÜ×k˘P‰ŕ0g Şkd¬”$śč[!ŮЇóR’Ä*&‰UDË_H,~'˙řµčÝ뇯Ĺ0Ąkç¤Rú¨ŠŠňó‹ŠUůţ$µuţkڬÂÇÔ'%#˛ňh›"u Ř˝‰ä$G„m Üľqë¶Ż“·)<ŮC±;s‰ĺŻ­h©ó?씋ľŠV´±ÚˇYĽ* –hHa°±5}:úRÔ˙oçŮendstream endobj 60 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 4902 >> stream xśÍWiTTǶ>msPhšnTPAA$ ‚‚"" €Č1Ή”ĆhDŤ1¶âTÔ (ÎCP "Ňh#‚$­’hÄÜ]}«}÷ŐiLróÖ}k˝źouŻ®sŞĎ©ÚőíoďýmcŇŤ‘Éd˝§/N]¸byXlZShBâ inî/Ăşáä+HÚ?GësYd*G¦&E¬t–x”lďŢ˝ąLć7eiznĆâĤL[‡đĐŮĂFŚpükf”‡‡‡íÂÜ?ţ±őMXľ81Ív˝ČJHYšžš–Ůµż-5`ąm­dBJlĆß&† ńN›ăłtJz”Ż_ĆÔĺţ™+¦efÇ~ł0(7.8/~zBȢ‰3“B‡%ĎZž‘:{䨕®nîŁwŚ;ÎĂ~üĎ/†=ŃÍńg§ťÎ1. cÇ„0Ś=3ÄĚd&0™!L3”™Ĺ80áĚ0&‚ÎĚfF0sĆ‘‰d¦0NLăË83s?Ć…™ĘŚdü™QLăĘLcÜ@ĆťůÍ1c`f,3ťÇX0–L4Ł`ú0"cĹd3ÖL_ƆéÇ0ý™Ś’YĚtgz0wS&•1cî1ćĚR¦3™éÍĚ ľˇŹŤgň32?Yěu·ŕnÝJş5ĘűĘ'ĘŹš(L‚LV›TšÜ7ůëĆ.b1çÄĹqe\ oĹ/äwńB/aĽ°Sř­űîéÝő=ö(ęŮ˝§cĎâží¦rSwÓLÓÓf¦f~f{Ě.Ő»šź4Ňk|ݬ^?ő¶ě˝Í‚±H°XcQbQmŮĂŇŰ2GˇTř*v*Îôńé3§OrźŹúlésŽ›ë]ćjđHµ §ÁR±,e;9˛CźĘSŽě~—ĘţĘ5ÂRľĐd%¦Đšă*¤ĆˇőIjËşFŻ'đYłµâLŢ/*ľ3ěeĽ˘ţWëžŢ-‹ R’5c[ľ5đęĎČTźhĄâLoÜUďG·ěŹ{PŔ9GfS$N±„ĺ`#˛ÓĐz=®Á\rŤž“ŢÔÂV-¬ÔZ6é I7]g­ŔMV ĺjŃĹ}§ĘĹŰâRőĄkýP[\•s± ŔwŹźĽü ŞĘ.O8‘p2ň+?$ NGřKčŘúC9‡łżLEq(>?eYvFNÚúŮôˇňT„­ÍźG߬>°ś®| s×’Ä~(éă%+2W,O]= ŠĚFěŘ(+n…ŞV9ÂĹ"ęjG|‰o› ˇíoa2Lsď$#T›˝ÄçW˝é5ÓÓĹ9´`yMŁS™ëejq‡VvA'×ÇHLw qGĂĐÄ”điSíéiÉ Zß«3ď§ż@0˝zyÂ…ÜşČ5‹W¦Ą†/ö¤Vv!¤ xxăJîŇoTG2ö¤ě —L%ij˘ÁĂ5–—%ż]lµVt\&iâ8Ěť ŻX^č˙ d0|GC7˘R)Ţú˘Đ%ńÁB“yAâĎ7Ç Ňsúř‘*E‡ŰĚGĐ z]Ô¦2Ç€´ř¶V†5úTŃpŔ;s†@ĂmÖ_Ňy€o˛ôś]=Óá:ů3+8ÁA° „lČ"& $Á*r‚Ó˝ë/âŰ0™‡A‡“é$hŇ02HŐĺűĎ´Ż•µëäđ!´x Ö0ňńH­aË»T¬Ö|8sxJŮ™ŁŢ¨¶¬Ą§´VÔÖJÔĽ%QóŹöUś>vxߡm×7 -Ľ˘dKţúÍ«ű‡Ł…Kćz ŠÚĽt5T˙mx­%Żé>¶ZCţ»TgŽ?ír{y+¬m•ă@l.ĽńżN̨ Ě' ÷(‹‡Ţ©*MÎőü˘,”`•ě3?a÷,ĺŞ=öl,ܸ­Ä¬f&|@!ďű¤úµ&ć¬ý!Ő„}ţ_Ą@%6ÎŻąWś6k‹Ň\ż/S źjáVvN‡WiĺúH,ŠäšddsÄj„±ń8Rľ@9÷RZ+jŔ˙7čÎ ę¤Vľŕ–1i!+š’:o¬ß\Â"b-Lř€Ś„Č_›Jš~T goPčŽgÖăá5˛–f9l§¨Ť†AăČ _˙ ¶\DqjµZ˝ĺóŁĘ:~ő§« >BBâšÂ§ĽäY#fÔ–Í:ç縍Ë|BGZtúTgRĂ+ŢzBŤ3§čx—úZx)tęq”Ú˛ş¶6On°Včp–•â5Ţ?ŽTň¶a~îÓbOßQb~śÁwŻűM©Đ5˘Š#µ‚O-íJ!ŻžË!‚RΉ.*ąĹčz”ZA4ŢĎ:qÄÁŕIl±'˝„ Ă~VňśFo§–í}˨wźJt-äŃĚ ÉyąKç-B‚_|y‹ŞÜńCžôĐL P45Ąźë:¦´>ľhÎĆőí Ž°#;jp´Ą.8ŇmžsݱËď¶ë”#ee­°»YŽż­×númDBÚG{«ŕŻóŻ$⤠ńIĘĺékR7ÍžpŰ(=¦ABCŮŇHŐ %e­ś¶ŽôX™űÉ’UÓ3Rć!ÁńnČďw«Š.ßPn‹8Ľü2Ú‹vo9˛] CŔ_DK×ĺed.NYřQŽW])9úl·Şm××[ŹîţĚľMôř“á zŇOˇ”l»q¤ űB%Tł˙ż ,‹YgJxţ/dĎĂA|a›„­% %–Ę:r0…’`˘f_p`Ń`M˘ŮN:Ľ”nŔK-»Ü —Zĺ—)ÜďRîń§§WĄŐSî+Űiüű€×č·D9eNúŚxăaŮ/ęşRMđř‘Ë3UH«çŐ˛GÔxoşµGj‰Aň=IÓęűPçôĄĚ% ޤu+~†˘%ăV-ĘÉOB6Łü-ą[…Éü޵{?9€Ž c;|uxßž_•AľŢĽďź‘}ś†őx-~rqőwŮÇ+‚ŽůĐŘčBLńl·;°hj€>…ޱ\ţرľHp™Ő˝Áú˛ć§şs } iĆzĐ…tCŢŢ&ÇIV‹5@›>•lĂĘ6ąľ]ĎÍ ă XÇ‘ lă°™ˇŤ}ktk#Ô€{Ł Â*=Úpaĺ©ĹO'\FwâD1šL&˙4†‚is pű)F™Sç% 4˙ŕŇsŮ߬˙¦ŕ’°ĄFÜŢqăÎ$hďřŹŢ„6lRÓťT KuxŹNŽmôą"I vÄ™ä #,jk:RyCŐtŻX=ř¨Ŕ‰$+=LŔő7bJ‚Żś‰‹=Ő+ĐIg•1g`jv˙zYMp;)ľîZî¤úëŇퟡ‚}ĘZ>gëęÍyHđŠŽ™¬rőóŻ3ĚkĆóZ» ”ia‡Vö“žuČiŮş-B.w ťß{ęäąÓűĘŃ=>ßH)Ée©Dŕţ&°"řgUs'LëŞ2Öß:°0˛ëX+T4ĘńHjÂ$>ööśc8›QD ^Ł‹üÎFŞNĹ\]vÝEß-ż+¤óČw킬´) rç ´¸0óëś=ëľÜx\Ăíphś˝Ý;t˘ěô…=wôp Or‚ĹöŞIÄšX„Or9Ë(7®jžýOőË D§ĆÚ‡'ž#ŕmh¶g˛~ţ†ůý›_ťĽˇ|ëÎ’XŘ+F‡=^ťĽ.Ů—Aě.ťy§ źđéŞ?t˘ÄŇşf*ĺuĆđo¦QGެ]©VĚ+Ě@‹„.ˇŘte°÷üĚŁ”đÍűŞR. >™N‡M(ěÓę¶ő\sIÜ(UA š˙EĚîT`‹¸¤ëoę(Óśâ‰'´§ż»š°śXKě•ä™Ń¶&TÍ­ ‚ď›uEه˛v'ŁatLĽŇ2¨™ŻßZŢ}2Ž*ŮZN˝2ΰż™S´čSMĆÚ=‘t'…ěµFV§Ă2ĘJŢ%€ý°f2‘úÍÝÁôu-{™ˇ‚is^^¶…Ú ř¬¸”iŮŃ«g ‰(|_RYú·źÜ|žVţÍ»cŽĹUú?I9jE?ŞË‹+NŻFwP{Ř]‡#äĂŠľn—EW…Őż€Pá¸Y˛’¤Őë ßR(ĺ’Ř6tđłóňć|ŠĐć<Ą/_¸éó‚ÝHx^QúŁJoĆC¬É8»fÎ(fôĽV_Ň„ů}Öi µ°ţ]]W˝”bţ: ‡R‘śł€{üüH ű†#Éđ’ŞÉi¬-G2HkTŞzĄZÖ˘Ł%^Ž+¤ęąćBş‡Çě>”¤L<šW‚®x‡3ť'ż»€7L‚nĎaďŕŤPKÖ<‘#}yě»T#şďűV°Ť¶™oxG’ń;v({hbLĄ˙Ör¤K_kĹYc×qR’vZ^ŃđđĘ­šŰ'”äť4!ÝŢ*Žź&Ýâřçá—†ůĹfÍR¦\Ť=čŹüPô˛ůA‚âěŢüźľ]čWZA0µŔž#ý ĎČxüŚZ@ĆĐËčĄ=!Ôß8‹_ÂDĂË÷ĺ]Ł‘ťm‡’v9ŐGŠÓPHÚ˘¨čŕLGŁĚZ÷(Ŕ†kiüĺrĹĎó~P.Şśq”FĽ§É‹ň´†FG; sž÷ D@Dů‹]q#]mrŘ…·†-múČ™| ‘eŻ$ň„ ăn}$Ő>7ĺŻ(†˙ĺ}óźŢ’śB­¸ŚfdŹv9ţ¬U4tçv\˙¶¤őâ«Ë}˝|±ž2íĆň+±Ą±Ąłż@ŁPŔ’řŚ„Ő1›¦mÜg¶ŰUTtöűĂUHxt3tRXňÜ D•Ëlâ0vAŔ:2ҧĽ/ç-±Ş}j»µ˘–FÜÉ•lfµ•1c\gE¸ŚwáÍ•·ˇ…‹ö.)öŻKę e~ČóVčמT9ćJŃr÷đw•?öóńő¤?±źäIF|Şlă6źÝzpçő©sŻ AS=9275ţ#Őň5)źFL`x“ QX—HĽÚŔëm“^@s]!”ućáR“H28Č€;]%Z5ŕŇ*Ă($éÔ5†n\„ÁŠ}Ěť©8±—nóâf ÝŕÁ#Ľćťz”EŤŢ5łpéţe§Ăď§<˘FŰżę„á`ëü’ Ś[•şPu˘X¸ uř·NY…îžN^AWµżŔož™źž´QHŕo~ţÝ÷č‘đšżgő§»ĚşĄPĘ™PJ ŰH9ś¤Z Oä—35Ű‘ž_O* * ˝ť˘‘:łŽW ‚ľŁtDá7+}v‚j3x_}ůÝFgăżôhI-¶TÍpt ď\óSŰÍ[­ďsđŻ˝ŇůÓܱ‚#ždĂTâAň…çÜ)Č~łÁ ]¶}ű–k,KÚۡ€ţX+ŢĐ6˝»¨č¨?w°ř^?»k¨đłpó$ňiďĎW*ŢŚŹŹ›áŮŹXý2 lÁö—v›ânxśRvŇ.ÄLťăíuî^MĹą*Ri˘xÓv3lÜذQŁC®57߼jÔv™.p»QVÚĄ/ĺU0FÜK„‡SˇőíÇŇ3wÎת[´ěç>Ś˝-ř¸Ôôö>”¨HßvgčsŻâŕ•ďUÄ;lÄŚśĘŻ Nµ·ý]ܧŹqăEűÍęÇŇvŮj«źÎŐ‹^\™Ă ®ć°“¸DéĆĚ.…ř°„óÍ%Dö!E,‘…Ţ˙~ӽƎ;>ěď´˝qőŤĎ[pßŇIstBm§ şuĘ!ąS´·ďäđ~iřë?9ýo e4kGjEű›ą<šş*{Ţ&Jťş“矪Ŕ”2ç1Čë~«“áăđ»hČńĂ9Ü`“®Qbä˛NŮ]5Íňń2±s._pmĎŃź Ą|ČĆäyh˘0„‡­V˙qžľ-Ą“úÇrXMóÉPbD…ëřŠ&±+śŘGÁDîÜ*Ŕł ě„÷ŻÁ”ÇrI_őD0 kka×Fě+hŤ$”ÎnQÄÓŤŘ tDőohOÔĐůř˙ESDăy˘ý NĆĽ1Ží5j©“Aaťś"®IÄů‘8çô§číű†3 ćŐ[żzKm3Ě úá1|ţ–Tó^itPĄa,Ř)d­ť˙>%Ég´0;I x4Čao¦Hĺ_łf;XĆVdÁź­Hß?[‘'ÜęcěŠGWG«Žd­=».Ĺ·ď®ő»¶m߲ ŮŰ›źą,3'%#{[QŚjíÖ¬…?¤Řp Ů<,/ľV–v(rÝ´)ź ę§°ţľě{X+‡¨ÉÚ)°VŞŇ,ľNg w¦ŕ;žIa] IaßJn –TĆDâé‘lµ‘Mą”dÍ»5ěÖč×°ć™Exż‚ŐAEś¦GKOÍ禦-;LÍćż> stream xś•W TSIşľaą‰ŠŠ\/ËŘŢË›îvPQ±ĹiµŰĄ[7Ŕv[´MÂ&°$,‚¬M*,˛#LXEdWÄ˝§]şŹJKP[@_Ź:.ÓęŚN]_1ďĽJXOĎĽwÎKÎÍ9U·ęŻżţ˙űľ˙ʰ˛ x<ží&//©Dş)zˇŰĽ/Ą¦ąYÜ ÷7Ó 9×ř~ť5°±6V?°sµ?NŠ©ĐŰ–°äń|d«Ą2eThpH´ó'nn‹ćÍĂżKťEJç/ç;oŠĂĄqňđPgˇ$ŔyĂ|ŻůÎŢŇ8<ęě"•8‹C„AÎŇ çm~ÎŰ·®Ů˛ŐŮs‹ĎöÍ[gĎ˙ŤWcC‚ \$~RYd”<:f}lśP¤úm ݱĎýŹË>ţ|ůŠąó泀 |ĄÄfâ+b ±•ŘFl'vs_ÂŹř’XM|Mxkµ„áI,$Öë‰ „;±‰đ"Ľ šp f$1“`–°!¦S‰U„-1ÇŚ°"2yÓx[x÷-ü,~´ ´üŢĘÝ*Ţę®őë¤y‹?—_- BÁ\&ZOĚžřbRÍLáäÉ“ă&żź˛hĘ­©ěTŃÔć©˙műˇ­‡m¨­6LáôŔ[ŤkŚvé÷ďî˙sżŐĘ7ÓÍRµ‚ ňď;:–nG+ä µ®J•^0ĂTHłŹŞJYęVj ÁcUĐĐř[¸€¤jĘŽŞ›š%j—’On6vžÖDí`Pč>ľB‚WÖ«ĘX8›,Ĺ«XłśĐČă2ńˇűÔJFI"'÷Y—‘:“!<É~LĆKTÁş ˝ŠÝ‚&xÁ ĺ9şŕ¨S“o™E*÷©‚ŽŞtl ­Qš†r¬ă‡üŞĂłŻÍ–ęcÔě]¸d-‰QĹg€'Ó[fč­É• #Ľhä}×sű-ą0(ˇ!ĺú+˛FÖ®.BÓ_Î…–ĐňĺKH1K čĹ[ÖxznąýhŕęŐ®W|>e°a„3Śđ”9˘}»űBűŕě>Ę‘Űo26ÍíŻÎ{EIQa ő‘A•Ş 6ĹRbŽeKŐ7 Şp,%ćXâ- Mqd©Ë¦Pâ\¬&[ÂZŇë€ZüúNg—Ú/Ú轡(Źl7˙»‹§/ÝĽčůŮ8?ÎíZŔéÚúE¨T®yŇÍ2lŤJsÇHę÷zU•ˇCAz˛*BVXţ5 ëŹ\Ť¦=ź -/ť¨ÖW±hŁŻ”d‡ŐŞĘYężŕ§¤®{†Vp6´ďž•«<}şúv]ďąŮîáĂ a*ÇhŠté‡î5 ‰›@ë“;íú*Ń×—Ńň)ç¦ô1ăLR«L¦YŞÎdťéF­¤çÚ|,Ŕ IRÓÁŁ ż@"W@yČ Ęęj®žĘŰAŁÔhwËłŚÔfNíiđ9Âňgé#Ę4Ŕ  ś ő•jŐ •çF«ărăš ]]i`obĘłkCbŇRÓ˛a™(€ş‹VĆ,ž÷6îYŰ‘nL{ˇ!˛Ą{ýлٙ }fITr9;ŹŻPKšŠË@Ă!ćtÄŮ윤ĹÇţóě0¦Nyđýíłä|ˇ}T Tň8Fµ}gj,¬ťGX]ůş:|YĚ<ąţDšr­G3«WđÍŚ«ĹHľ‡âI—Ű˝˝}§žÝ|­‰Ŕv° ó׳7‘+nˇ›ö©`xlJ+ `Ƭ ů“ÔŮe_¤HĚŘ9śđĺXžĐŃ16ľÎÁŁŁD+‹ĺxó*î÷CJHr`Ą¤+jt…ŤÖĄäX<Č12W’Đý|(Đ Ŕé¨V—4C řłcĄyůő#ĆŕJŁĺĆpŇŤŇśXY‘12|FµĘŔ¶B¤R73Š€S2ű#í¸Ş­[H}Ťş©)2'šĹ[bĄŮ!ˇYőXë.ŁžÖĆU¨´ŔéČÓĺU_†=ŽőyÇّԜ6ÚťÁ ăt8+X«$Iąąi ňÚţÍÚóá·+C+•5e Ĺ'Ő 8–[zătÔć\}‘…&í®*ĹăşçŰĆ+µť·˛ŞSŮÍ3*s0÷6Ľ˘(ÂT~B¨¤ÍŘT×Řq˙(´Ď†Ý9ăsŁ]q?č[Ú±ăTHś$c űHú)·QÝiL$ĺjy;C]«…ZuEKxkÚoUÇ$9Ěo$'ęĆzČp_íÚ_9PÍ˙[n#­ ÔZú÷ą­"ˇ3z—•»&%Ć).0"ZÔyĹąŕ°€’ŐĹ‘D(b%{šö^xu:iň8›Űh=–wł|ŰÝî‡sűĂß8PŻąPHŇÇCÔéŠäly*“™'ÜË×u śŞ~§±”ŕĽJ-Ö'Ö§ÚĘň–zÝűąţč o4ó4ůůG‚˙[Ů(Ď:L…ş~€żÔ~NcfZ<Ě%’#< #˛'# A%XP-fcAe©\4íéěśm©¨Şe(oiÎÁ”V±ę0±ĐgpM5ú‰V¬YżýFßźŻ_íşÜ±sç°¶Mč&¶ß&&5+&•‰ŰýuZXÖťTöŕq˛J: ýŻČŮĚž…lŃÔ7C{řÁégŐěb8‹Fdéµ ť?‚Nđ]ŚĆ]€M§ą8#ďb?ĚÇl‡—ix2şy#ďčHÔN"ˇ7ôެ†'™%E4đkS|řÉ•ËŔg Z—Ň™|<Á÷ŕǢíuĹ=ŕ&hH?´łdX 6 Fš‹wX.ÖbéŰÄťˇŻšŁ\ş|×BfďBľY”LI‚ZÝƩĸ˛ď[ˇYfBŠĚ„«ňÚ…ü:&/éôjt Cš—a”‘÷—~ŤOŠĺ–ÓĎV=E$3|dP;’|Ě´±cbá\\ŕÄž'Ď1ľż{-b\aÔsň—¶M»Lö‘ĽÎënéëzěj~ íËë{4 ˙ÉšNp…ś=]׸9Ĺ_±›QjÂJ÷ÁÜ/Wş‹‡Žc$¤Ĺ)(Ž.JP/RÖîëS~çţv#ÎŚýŰ®G-Š ľµĚţˇ~!¬%• 63Q—ŞQ•rŐs ´iÇöă"őĚŘó¤6­&±š=\ ÍŐäEV¦k€ ˘F{śEŰAűýŞ„ŘxâĚůÖÖÓgZ„ţě;ô7Z伷n) <šÚK kët¬^[nAß?ŔĘáŕ™q=Öv˙K¸Mdjá>ĺ2Z/FZľć¦Aáż´€Wţż- ĆÉ%hmEtÇ.üŔí..óLUĚt&bp*±Ś’÷µ"‹qąl*,”b¸bş>Ş*<<**"Ľ*ęŘ±ŞŞcŚęŐF¸ŐFŢą{wîiďUÝłä$p ş‚Oî?$j“,×-×9jBęÁ Aç©“]oËÜ%ůL^äˇôĘá.ŇürU]°<-)2Ť×íÔMÝŇĘeîžťžĺ,´’UgŢU‚Ďťv‰w¬ŽÚ›§föÖfµ¨JUŞ#¸Wr\Shsł /*©-bÚ"/%]ÁÚ:ńÎă'Łxeä˝» Ën[rĂA‘ë Ő;ëzóM›öĺŕB;‡TČpjÍm/¦ýTkxĎ$čĚƱŞmP(×PÍÓ]ńMňÖő7Č1B•0Ú Cţh‰WčÆá€&Ťš?®Qť4(DÇŤ{FyäĎĹźş_Ý~Őí@ťĺĘ›éE~0ü#ŮpÂ|i`J„‰Ż“Ž ;­Pôé µrF„9ßa噸ڵň™afŘ<$u¸<7$äłđ3>uöçă-ĺE [$ĺÇŞ™ \€CRĆÜZ?´îçĆŽćŠÂˇUqŁ«JM«FďűŘČQq<Ř…ź÷ ]ŮţB¶¤‹q d #;1Eˇ7Ž’Ŕ· F¨Ikb`ęÂc wéş!ąŠc}ߊňiˇŃ­ÍX„îĆę^8Ëhwţ)´ďoÖăęěÎí~4äňYúűď1ĺЦżű>8´™YYŮé I ­>ĘP÷ë ĺŤç‚.ĎBżĂßÉhJ…äę_Yę®Ňá¬bź{ďXďŇů˝’IÇŤ$Đ.}ßq«ç¬·§ąA‡3ábČđ°G3-ágA·‡Ő…e!ˇâI㉚ăÇtŢŞ=¬Ď…ŽÍáťËzáÔ^Ő m{yuÝÝĎđc Ăąóô˝—vú 7ľěä–sçO\ąĎŔ´^Y!—ĄĆ&d0¨üźźdĄdg‚4§čr…ˇ¶°âP>+Ţ˙1O““ ťţ4řľ+şęë+ňY±ĽÝçÂ…ö«÷ôw.JŽ:p ąŞąQSŁŃhd! lĚ “ĺx¶˛Ąą¤˛¸¸Ddr®7–SĹń¸đ4Đ''"\áńOIááb wމÖ*Rľ) şv§¤'1N ±xI*Ľ‹ľq,MÉXUË Ú"ŕ–ë<.‘łĄŰD9xÓ2A”-µ¨´,|Mj[Ôí,r±jT'1č5™¨‰ŰłKYř„,mĎicÇyŻĐŕđCÉEč.üĆ1AťEt’,ćđ’4Đ „źä4łK2CRą»RĘŔ;p·¦Ŕě<¶ö*z @/ŚQŮ€%—Ť¶‹MgŰCR«j‰Tb> stream xśťU{Tçź]v†i˘(¬«¬†Ý‰Ż(MDc”7*Aä© š…`Ăľş;€XVP««""HV^ŠŹ(Š$š ŤQÔŤő#­&ÇNsŇŇšöů0§ßńqzNĎi˙űfîýîýîď÷»÷Ę(…ś’Édc˘ ¦´{śÎőj°Ĺ¨_,čŚŇq‚L|I.úy lůiRż‰5#(4ÂŤPÔżôâźţ·ĽĹÇŁÄ?Ť ä”퓵ÉMKMš>cĆĚ‹5ßfČ̸Y\Z>7láBy»!ÓĚM%‡\Ţh±šxłŔĹń<'dń\†ÁČs!ËbV.ŽŽŕ¦ED'pĽ™·éŚ\LNšŃÎEŇyłťźÎeXlśqčK·őÁ`1۸ ;§ăěV>Ý@.ńkÓy«dÉYy›É`·“3g°s™6ťYŕőś`á ćtcŽ^JOţgXĚgµYÝD,$TŚĹ.ŘÓm«Ŕ‘Ś1ˇáCo˛t‚”×n fÎ’A<ő–ô©š'6Ag0Ű9_+HyŇxNo°[Ťş|’—„˛Ú OȱĚ™OłĎäl|¦Î¦7ňöÁ¸*Oëăž©ZgµóďZ˝žä7vŢ0Ä,G¨µsQśD.'±kHÎđ”©˙Ź;Š˘^2[¬6»ł87O—–źľNÍgdf˛Ť&ůĚŠZFĹPË©8*žJ )*‰ZAS!T2JĄPaÔkT8AER‹©%TőM™¨‘Ô(ĘŹčŠR·Ó2Ą,Qö˝ü]y‰ĽA~^ţŘăŚBĄHQ\R`:‘ŢĘ(ĄĚמ3<ă=K=Ů—Y'ŰĆvĂA/[ś łŰG´˙8e+„‹­*ě9ĐJÇ\ĎiĺµWç§W'|ŇlMY_âŘšŁŤÄż—ŚwŕçíuÎZT«ţfůgo%X—&h”Ż×öĐ$Ş č…¬&ALňg‰§U“Ѭ51ď¤D_AsXěuřőíÉ{5—ý =`aôŰ·±ź&+Tʧ†&;í:­1.Ő„ŘeúöŻ@yűLJZ›ÝLRüť¤7’řpEz5Çŕ9ŹKĄ·]€#{—ť´\GjC˛B*(#ży92ΓŞAuîŁŐáX„©9‰Yí_‚ĎM? ‘ŐŽń %p(÷>‡ÄEhŁ•‹z\źžč™P*Kk‹ŔDßMe[ĐV´-Ő­ f•\Ă?IíťĂµű€¦ĂĆß8eŻxO”«¶×–íB»Ů‡ »°Ď;‘ąüűš÷yK,Z‰âNčż3ßµů*ű.ĺUoĆgż/Dg+ö¬Ő8Ş6ď.m`±S\PşmD«[V}l;.tlčF,Ľ TŚą ?>·I;c˙ŠG%r«ŮŰ©Q^ě:ś—˝ątkÉF­<ÜâŇ^YĽâ!ľ!6«0a M3â)t8“@_cÂđýbG‰­WÇ·˙p¸q[Ĺ~ŤűGɦŇ"¤ *kv8«¶»´ÝĐAÍ q,†¸eßż‡xl,xŠ­RŔüŐşyIIKz寛Ďě!W´×áÉ4`ÄÖµ%ů(_=˙|Ňw7Ďí»|NSA{ÁAäîsËDEżI…ýüÚc ţ$G'ˇŁŘ-Ś…sRři ^1 5‰Zéx“0ăŐ_7ä"> .Ée ßđ˘E/<Ůż9ŕµEô’~¶J4Nf`ž8zÇŔčgi:K$ú.L ‰ă”×ÄF—ŞŔµąŐ ň˛ťÎŠKĐé«ěÝ^묩ŹZňŹuŮÍÉUaĎBób-x, ăW×A÷eÄ~ZżŢ”ëČÉŰ Í+B(dĂňŤľ)›2ĆśDţh´ ńµ|‹˝)÷Ł §Đyt¦áÂ9VŮW\€¶üv<ÚŕÜĽŁ…W< LŞüŔ”ÔĦŘ\‡;Z_Ů­=[ńá¶JçβíeęÝÎmeU;٧łI훥ř@o9Ž©ęŞOEWvGjţ‡đgŐ¶F"ýJtr]›ń ,Ő‰^EAŮIQ1a:ü+4­¬M>”u4­+ď&úáöIĎâńŚ1ôké~óG×:«żhüD»˙‹Öć.t5VçV8 ËôŤb4\Z&Ţ Źdě¦ÁÉŕońUé(Ć3Ť@Óx÷á*ý<|wĄ'NK`×Č'BŤÇUÂ9]SRĎC©I‹’CÍłP ‹}ľ |tµł©ó´&Cô!® Ă>A€†ö0’řG­WĆű?—řČ`Ů@Ž«č'žȀ‡č†ř7 Óa¬üzá×eB—ĦxrUUíĺ'Ń1tz]‡ĺhfűňĆ`´Í7®J^™J {…ĹŁĽ Ţ0˛ď2xti°†Éă×ŘRË·víBŰökacŻ [™]‡*j«]Ť‡ÚęÚĐÔ˛®Ú˛łŔY„˛Y2HűĚîýţ‘L\@ĆÂ\¦ŞłĽĄfORW˘ĄűŠëôŐ9וĺŁé(Q—ŕXâ»Pw€HIh˝b$ÝĂ Nä‡?7T3L%Ş“Fž›‘?×Úťv ©˘E|ââĺˇXŽüY,ż9żŻ»­î‹Ëšß;–ĬFje_rF}‹¶Ś`5™))$cgâ›ůyGó?ŢÔŤ`ŮŤ}0^»HWâ“Uż;šDD<鍤ěS×`Ô- {´O–Ú`o­ć¶gzě4×˝ÎĎ.#uGł5YÚhą˙ąŃî.ďśg‰JÔś‡Ćˇ %ŢoÜŢ3ĂkARŚômĹŢŇçŕĒ؇ ý˙%é1ű˛ű.ŢDĂ\«ŕ[(€4żÉ`;Îx:áççoyý4ňÉzîßÓ¤őňĚRşwČzľ^Ó~ęü„cMBVa醒"mţë°±ćFű‰KHÝş7/ł°¤ Řˇ Á˝Ău–·8÷Hu&uĚŠH°ĹĆkgS˝‡– U¶%¬ňu×=zÇŮ˝·Ŕ{Ň#ĺýţ˙µvĽkŃ ~Č‹Zʉ„&üO "ŔTŮ_`ŞĘ§Ňő™ú÷Š ă|Aţá…Ďë@Ţ~ľĂ^PBÜH;IžŇšÄV7,p§40@żS^zĎőo!ŕd‚endstream endobj 63 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2173 >> stream xśeUwPT׿ËÝ{ϵ-DĽ€mwŤ `oŤó˘‚€2Šti‚ŔŇX¤RT p&О*‚ęCAJDšMô˝X˘±ä™DM&ů.2óÎ2ÉĽĚĽůţ;óťsľň+2FnŔČd2CŰđŔŘřX÷Ů6ÚHŤţhš4Q&M2&łh? ÁdŹfńhy٤ÖcáÄGhF +“ůnÝm«ŤŮŻžżté!0(Xęáµh1ìgśsĆ…YƸ1îŚăÉŘ0¶Ě*ĆŽ±g…Ś#cͬcś‘1eLé89Ęś‘É2díf{ nłÓŘ9#w’7q“¸8Ţ€wáóř/'ĘEďˇY!ý‚[$s!ĎÇľ#X Să–ZŔ-|@~j)OĐąu…'°pł:bĄŠěA©)›˛8ČnAžů;iB96 {n€[‚f•ňš/2ľCĚý¸ŕŻČ[šę•Ĺ)¤ű{:%‹NY=¨ ”,´IY"™oaAć™Óa,KXhő™­ĘňűZWSb`żŇÎżLAląŰ§R ŽÝuSę˝%k„é¬ô¶R„¶(–ŚII‰ËHü< Ź'Vó~°űîW\U•™^­:śtLÍ݇eüęJ‡Cöx*^ąÖÉÁ1l¶ŔdÜ "ż®-úfr?ľ‡ď–|Y)(¤DŰ +ş@j{6ö? €0djü¸‚hE(ăs[×ć§ć`:ťUť} °řÝ{Xę%ݧřx'9«zü‘q ™FŰż3tŤ¶ď‘É?WHá9:URUT…ÇíëŐd´łÍÂÄmű âU é%ľ&µ_•5KyěŤÁ…"±ëCşßŹ•p°Ť'9w)báőń+öÍĽgÁN ŠăüÚšY;»ĆčŇO)_ýŔÍ/ÝWŠ…Ű5[lUQ„řÍŠĆ Ë»<ľîęŞhęU6Ę5‰[Ň·baٶ¦ővgڬ˘¸źÓ%±`îůę2ŮcÚŠ&°00Q$–~ś¦˙5Ą\v1ÖÇřŻńĺýőşw­ÝĎ0L\ňŠđ~)QJ8ŹţX)‡¨˛ <ď(^u:žş;Q ĄáÜ4úQĚž‡Ň6ŮYÄJš±ůDůĄl§> üőţ»Eűs˛¨¦ Ł;ŹePÄ7ŐÔśżľî˘9™A5™E,~ś˝×ŹžíĄŻ}OçT'É/ìZx=L€hP°ŇřAµHٰ˘ČĽŠźYSÔÄš3äí—*.\QąÁúf䕟Şă?ˇ{°˘PD÷†şÄ-»´{éľ—xÝ9ŚşÖ˙myefz ý§|÷pę„ÉÝôŹqব´ ŚD—PŹžX°\÷ \LCŹx\‹pˇćź}C5ĹÜüc2›Ě|;¬îŢ-;˙Ą’ŔA‘¸ńyĎ/ő`ˇ»nÓ’,ü9ÎR)ŕÜ*É{ ¦Mö#˛T+ZůŐÉ”[0ˇ‡LčA8ŹĆ>|˙P{Uőkłs‡ĘŽăjˇ)ě”KЦTm¨ŇŢkł-žéer‹üŚR“˝39ĹŕBÜ9W ôŠě70OPłµ”ô>čZ¦.•:…’“ť398ۆś ’u$ BÚCŔU›jgé|‹ý;‚+·×ďjµřLŢŮJŚLśEc5Ž*ÝÖ˝ýŇž®Čćřşcľ+żvż€]ÖCć*-]ĹVţMűĆĄs˝Ői»pîNÚĺUŞţ ]×C°űL'*=kĚ`ń`¸ąeSŔ騆 uµ-ŤQuţ*ă—ÉvJ&ş ŰĂZáˇ7‚Ň䦗iĄĘϸMşqEé0‘Ő ‹Ů*fşCŚjä“’ő˝u´!Ç‚$'5ÂhTşóš»vT ®ŕféWJßáW@y3ďRBaa€ČLJĎţˇoQjŞK§ř`DëfëC_ »– Uj{}áó¤lÉFŚi ®ôĆxCĽC° w¤ÇĂ5ßúË‘†Í+đOw«+9YX‰…ŢŞÍv*’…R“‚ô iÍČż@źđť.9YDíďvŐćłżśżŰßĆî9Jăyˇx}²ŤÔED–űCiJ™ ^Â`p©Hž -ä>…^# ¸‡„“¬A”"©#1ttvŢ€?‚Ě2ŮTc2ÁŚ•"ýER’C>!˙Ŕdż@\ŢfŐď`Ćó_‘nž;6{+O€Ő“§`vŕB–i$­âé#˙ÜŽ:MÇz«©~NŽźú<‚Ĺąĺą§TŠdť”t–ë:ňy˘Ĺ¨s$(F1ĚŇWklendstream endobj 64 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 6044 >> stream xśŤYTT×ÖľCąsE,p)ꢱ$ö5jE  (*Jo2´ˇ ˝źˇ#˝÷˘#v¬XőĹѨ‰ILQŚš˘É‹ů÷5‡·ÖfLň˛3ś2çěňíoď}Pz:”@ 0Úho4ŢlŻ0w‰jr?AŔOÔá'é¦áHţđk;}d¨‹ ő.L_1ć§AŃŘ4–Ňś˝‚V”řxy‡Z,7oáěŮä}™ĹŢH ë9vîűü‚"Bü|,Ü÷[Řͱźc±)(‚LúXĚ ´Řëáíîďiäiáä±Ýb«ăZG‹u›·nq|gÎźĹSec¸=hÇęÁk%6!ˇëĂlĂ#ÜĄ{7FڿÉcłç/oG'ż­ţó˘ç/-\´xÉ{K'/[>uĹĘU3ŢŮ9sÖîŮsÜćRÔdj3µŚÚB-§Ţ¦>¤¨i”#5ťr˘¶RďPۨw)gj;eMí VSł)j 5‡ÚI­ĄćR6Ô~ĺxĄÉ&]¦‹LłĚ ̶™)Í Ě›Í™°pBô„K &®ź7ńú$á¤Y“ě'I&5ŔˇŃ|-Rü¦ŕߊ4Áćał.źŇ*B%©ărS˛ĂP ÂŁřjÓÄ#2ą? DŃ(ŃŹęŻ1•ˇP”’ź’’€b™€FTÁýJWÖŁÖ¶ä%®űM–ĐuSô˝"@=Ş˙JW4˘V1^ ŰEŘ”ţ|˘ŻľzN ăź”ŕ¤4aOň…­˘6 ŠćÜ †ţeűńë]}¤RŽU¶Ł˛}ś5-!Ç5˘RńIÜë¦ÁBş”ś®ú¦Ř ÖŇlËË{GÎ]( ÚĚáýBőľ&ŐľŮę}bőÍĽLaÜöŘěťÁŢŠü5ěMŘ»|2‘!Ĺpˇ4~ *ABőké2ŐůdV<…Ž‘ ˙:T'^§­‚iúŐu¨­U˘Y &KŤ¨L\G!Ăf¸B?Śfk˘C džM˙Ť Ő‡… PńSئϦżŔä=14l`ĎoęËTB¦(ŕs…ಔşĽř‹ŔhÎ ¬‡őćĚŔFýač€Î?‚1g“/šcoiee˙Ů÷7oŢůô†ÝŢ(Ę;в·Ńhˇ7ufńŘçď‚έSťu5běç2̶ďkěđăE.Ë–YŮÝ~ňô¶ňËű'WŮjÜ a pSÇ‹‰ň¤rŃő>łKÔ'Ô\ÁŮŕjá^ÝqŐVqĎÖ˘÷rŘÜh¶ 2¶ŃRvXes˘Q[ĘA®„Ľ­ý˛€AŰ”‰y1ÍęĘ/l X­]%úÖ„ťÇGó#EŐqÇ–n߹щ;,d?Wźu´Hú ÷.׎ TNXŚhöíçW„Qś<¤"˘1µŐĺM—ůŞ^‚_•0‘¨«ËÇň)˘AŤ´"ę—ůjG0G Qgđ…‰ôßÚb"YĘfˇxűT• ]Ţ ŚDč7,ŞńË]Wlł®}Ě4¶·ýđui@p6'ŹĘŠjŔ­R Ű4YrçVㆤÄŐď‡.óšű*ę©LÜťôe,ÚĆxzúÎŰĺXô@ÂĄV¦#Fĺ.ń»Âh$i-,—wsÝ^2š ę´}f üo‘č%¦^@tß Ć˘JTăí›ĹeÚ;$„"f:ß †DX*Ň/}HaŮ" ů©hĺ1N§gŢňş{ď«ă}` W€«BđH ŢäüĚV p%Ľ¬Ak@§źI§5ĆžŠëŠĽž^äŤăĂŇ“÷a.-‚ɤťáś~·&I‡"©xđë5ä’k¸/'4;ć(2;О + ŹĺĄŮµŚśÎuîÄ#r’ŠŁ*Q1ęDŮĺ9µ× Ď´µFcJµ÷î(ŚĎ*!š‘”/'ž#iÄ=!7;‰áť­ßŕ·÷LEÖ5ŃőeÍ…ťrČĺŐYĄňTĎÎűŻăµéxĚ4“aăm®ŰýÚŮ›ßvšc-ýkĎd™ĐL2©ţ-"GřţH†-‰ňrEIě÷ţ¸ű»Nš3DL$ź»`'pą@>6‚‹ űůP2ßGăq°HFÓ?J—6 şyÄ`2l[MűŕýĆÁ4Ő|¨)ŽŇ`€gŕ±x±ţ>šmš‡‡†#ńw0¦ŹŃLâdMuË@ßS€ľB@X;Ź`îOą ěţ ŕţ<:…ÎŞnŕţ! ĎD (!Eu‡*'@'9!…—őµj/Ń˘Żł_ć©ń†ô Őc©b»)řť ăFŘ×?Řaš˙7śŻĆ>±ž)‘Éţf™tjUbMrŐH6mř{Đ·Ń0żÎI@é™!$y/V°ÉN^1™ Ę-,ł– ‘•Ž=~ *2Řýđľî—'Á´(G sůťú­ĂřCĹŮw•ҧË{‚@ÔR˘2"’ą”Xé.+Ä,Y}űű3Í$¤&Ô|ŚĹrď*Y=bęk*ZîNA®Řr3ž¸>ź Ć >üsĹš–) \a|ągOĎ—=0‘|°u|AS8ňăx™°]ěbX8G’aŇd‰Á뱫iśWb`J ‰¶„Ó ˇ8#/ˇ^‚dqT[J̶pkçúeB?jŘ\•1¸‡mŘO4‡Ë…E»o`§śŘ‚ĐŹÜ伤âäbT‚J Jłóľ…Ľâ ŚĽ?Vˇ©*ŮC‚n%tu‰®hK\+„›Đ]S-ĎFf‡Ă”ĂĎhߤ$_ńnáP"l„,!ľ‰»Ă#2ÓQ”™O-Şâř1tmŞFeĚ`ĐßRAz8kÇjY›ĎűÖ^@ű¶ě-ßCRŁ`&©‚Äl6űäÝß{Ž5µ4sě&/$;Ę p4žď‰ŘGץ«ÖlľÓ÷ăí›·ot;:iaţ¬Â{tůäÁšö­ái((“Ćůô¸C1ŮŮşaůK•ˇ†FżKP|ś†Ťýé%Ţ噍Ȭµ8űĎkjA†®}v Ć)ŚŮüţE&ĄK“ą°í[%˛<ýçčš*Ô ô†źńxęH,s*ŢE$ŰÄ ÂŚClTţôH—·ĺ/Š®˝Ź˘ß_µ{·mş¶Lř÷N–ëęµ9qôÂčaŃ<ú4ýŕÔĘĄî郞+o(*6* ]ÍuD•PŢRôĚę r8ôż ŇŢI=ĚÝ'ĎŐmŰc3“{ ҧZ<Ö·“1ěß7ʰéor‰ě:ĺ˙ˇOÖÔŕƤJ´Uş+«I–˙Żz&j'Ť)A2ą¤ Ď¨ tęÂuTXÇŵ„ÖČŠöŐż:«]ćß}đpxí˙V'ú> µk+jbŘ?jĂQ»9˛CU~Íчs˝ţ_GHw˙ą¸~8Ź[ ľźŇlßÓ[v1ß˝—ĆŕóŇšHI×@îźBm ,˘†ô.§Öc e‡ä Ô€ŽfTyśŐĽęĽzbęȵX»0Jś™‚v  fľyˇŻhŻ™¤˙M‰H ¨Ď<(nĚAzÖV/˘äz>đXčĄä3!ÍΠ G+`t„R‰,›Ľ8ŹŻ U±(M‰‹Kĺ<–8ÇK3˘3Ă3ČE’ĘÔ˛Ş®Ľ#'¸ţĺó„ZşĘćQ<ăó} QşIçý»DŤĹ–4É4;öęąď?ʰϮ÷śşńĄ9N»ŹGcË–x6ÇWÔÔU4§–$ćse§N·]BĚĂĎw/\ëňˇ­“ăM‰I)©Hfć߀Ę96žŇ,3X›˙É´ÄM­!ň.DŽu˛2zx_šŃIç–ťŤsĽEü\•FÉeűů2_™ßńPGżŚ](ŤÁ6BĽđÔ µIÉ•Ź~¨ţŞL,ĎCgQ3óDH|VöQůGegäőßhŔY7ŔEa|˘os_I(÷Kňˇ`-Bwv]µmíů¨ů2şČÜłţ ±áÚť6ľ ˛j•ŢĄ)Ółą¶¶;Ş&đÖY/×€ďabż`I†W†CZ BŚŠ ¸S4{đĹąőnrÜ8oߪ˘ÓÁâÜÜ|RŠ2őŇjIhXŚß‚ź>$ŚcňíÓgôD)řIÄŃ÷zzI‰;5ľ^ ŻčCÉ>\‚R3c#°˙aš‹2Pă[ÜĆA.¦ě‡e¦őZ ˛ęÁŔł9ë6–Đ _ő5hSŔb…ŕ±2‰+üÁAôËŞź±·[rŘ^ yŘŁ™ZÚ79ŃOŚ«„‘(´˝2'÷`×ÔŢUy…¸ţ¤µÝűk6ż´ˇŕRQ± ź¨ŘZ¸é7kAŚ^<]Mť^Đë%=Šń…;kľ€´/ś‰ÝOó~°UôÂ>¬ăěµ×•+…·ž?|ŚŁňřÜTň“‚"™ĘƆęŠÖnŻ‹ď’6ÇŁ°+N=ëű?†¤ňZlë°Ún·"‚K¨ĎŞGĄLﵳź}ua˝•ęţáü…ŕ„ň˛şŔ(Áń×tJy$JBŚ “ŠÝLU34¶Â}đ„uňí¨¨(járˇfµâjueVąaO ŘMđ¤tR=NUýźŔ, šîŰ]µŞů˛éd7şĚ<\ňŹÄ†ď­XîpjÇÁ{Ç2|ĂKówź-#0~úř'n)9Ř»Ysě!kű“=ç{Î|ńŕňNgq)ţXdc블c–Úö(W®˙ôňĆM*0ĂWpZŔ‹ů˘ěÓ>±HŠăłÝJ°›©<&;Ľ™SnĄĽ‚ÁKaĎ?ďĐ(˛¬:‰{”P˙`ÍöqÎM¤`]ĺ,¬;m)1;ýxčś?_Ńu’KŔcWΉ‘—<Ľ<'77U0ő‘ŐÁ’¨żĘ5¤,5%7nĺç"§­K—oűäŢŁ;=źoŤ ěŔ´ď/”®1Wáźě˛#ě#]xŔë‰:ý<$ţţž­ÁíGÚÚ8|Uď/s*Né…É˝Ţ Sz$v~WĹxđ—Eö÷ětńřĐrĺÇŽgşŹ\ąĎô…¨2¦""$YJx7ţgmZBF*J6“–GWŐçWĺpĐôz]ÎÁ¬\”ovľ˙wŃ=Ď«;vxn±˛ęÜrölçŐ{îă DnŇ ¸8ió‰®ĘÖ’’Ę/‡úUłČlÓ‰UMĹĹUÜTÂńŢß‹PUlA|>> ¶¦@ŢŠňK P•Yť´8:1=3QĆá‡x_bJl’š!˛ó`2|‡=LKł3 Ĺ”Wש˝ě|űámĹ‹:„:Äx–^‡/Šăđtś/YëTĄňti'YSËWE¨$©(!¦˛Âty"b˘ĄqˇR2›,†ŁŘ“ßřdµ0ˇUqĺ…ŮňÂRÂľÂ<µŘ*Q¬HüŘnˇ˛äśČb<ö›Ý`†@˝<b0˙ľĽ(?‡ôŰ©ŐÁx6Ĺ…xä©ů;¸ Ö÷ 7ćV¨5úH© ŻT"ÁČÝOĽĎn»kŮ‚IJDRLQrnş–bA^L*ééžXŚ'Ě‹IHJE1LR^DC ě!Đ*Ô¤ë×SHB‘ˇ"¶ Äô¬×S`Ö°–ĎVC`˙Ů ôĎK8ĚíP6„ú۸­ËGI:ĽUÖ› SčbÔá퍼Éh ž,Ś#zw¨,=OˇăwGę(ć` Lwh¬‹4ŕť¦ /DŠý»í đóh‘ĘË—gĺs1ö»˘ăŇŇ#S mÇ”EU´˙zt†É/#Ö¸ä.z˝ASa‘µEĺ¬˙LÁł†Ťm‡v©ÄWűU#úZ+ęúO˘©âŞ÷ŻaĄęNßWť‚M˙ńŢóőtuô„%ÇĦŢüŹMrt&BIf‘eQŐµůe%y|ýÚ&ż\ŽPŮčř"~u¬,Ę)˘Ę‘śžSád8ňHyž\ő“[ť“ghŘQ“•“/Ż’Ľxč á(Šú‡rŻ˝endstream endobj 65 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2064 >> stream xśm”yTSéĆďĺr“Ëčdt´¤Ú$=Je@ËÔ§wE0˛ş HŘ D>d“-a ‹„°T@QDŔÚŠÚqĹŃ9ꨵíôřÝśŹžÓdĄç´˙>ç|ßyßßó†-KaúGP¸#pTć‚a›1l&Ŕ~‹­Ĺ¶c»0Wl7¶óŔÖc^ŘgŘď± ć‹}„±-40[,Ŕyx<ŢŚżł‰·1D§­­Úökr'ŮKľg„2 L?¦v°č`˘_đMćCÄeł[Ĝʯ̄‹Q+:şÓŐ^y¤¦^e9Z ÓߢôŚ1ßÄô¶ČŽÁ,ŘřçRŇ„„"ćx~Y&ňBQżQ:ÝŚEd˛čÂÜsôşĽiVΰ“Na{_y $@ćÜ)DÝÜöĎ[†Ëą#Ć{ŕ>?ôĽëČÍ˛Żź Zś·"|_ôČkč: ń§<ÍČ=C»ôăצŢÝ#`M˛ĎžhlmTwŚ!`í»7šâÇsĎÇT@DíÇH«›3¸ő—2ŞłĘÔ€#MN‘ Ĺ<řť›_OD¶ú đÂĎ(Áާ˝­·Ş˛@SÉeÁ§š+´Ý…WzĽď·Đ÷Ř!«·Ç‘2ćd©µä)Ž«@Ç× ďŃor;™QYq ˘’›z«ŠuĹőĽ¨'ˇó´’Ń$ N/°VAšxţëŞLţüH†ÚŰJ´ŔŠ9[űž©ý‘\`ö ýĘ„GĐ•LýéÉ.ôoZ©Üá8ą »H]ś]ăíCôůéŚsG:±‡ÝĐď&4;Ôę¦>kĘ˝N/ëÁë´ ťĚNI’ę¤ĺ ŔYÜĂ7ŠÓ|Ŕ—˛őšl»2Ęŕ8( ‚ĎÎU7ŹqŰ™ńyiÇŽ*:]Ű©-n.ďâť»twj+9h•Ýë„ę" “D€łWŢűş=…¶Đ®´€R‹múÜqÚ± Ú*ôxăC‚VUlô©śT0źĺĢđřę„ŇxŔŮÜBâ‚Ó}€…Ă^F/wLq 5@ň¨ĐƤÖózë82Mұ,@ÉÔÚ¶š %MĽ÷ôkůŁ~ö`ŔAT~0ŕ€"p‚Ä}÷á–7˙¦üäń ËüĹ‚RóQâá÷T§-ˇ˙Ůk´ŹhßĐů°v~”ĽĘ€v´ąV7eŤxôBC\çĺč(]Bž˛pý­Ą‡ řŢŚł;Ęęő •jŹ5†ąltA[%Ü/¤…’›ĺ¨7qŇ×…‡r ꜣjK+âš’;ÇLwGą}“őwk^ô³Щ­`4Á_´e:E±č`‚’‹đŃśŢ˙’xňúcµAŁ5Á`CˇľPgIµ?´8tžŤímä…×… z­-ŇŐXV´ŽZ‡–¸oCŽYę˘"µe“^Í0˝¤µZÇë FŔć}l™R)“¶¨ÚŤ§ZÚŤ‰§äĽ”ČFkâČćĂL4|,éxČćjLş`´Fż)ÍQć§Jš^ÓZVtňDď6ýɢO[ŚyŰŹż™űźôIó ¶@X(ää䊻O ˙%ŕMKúÓ7ĺöĺ^ÇčĘ7§¦2É †ą]‘NfÎXvű / k.¨Çi€·±'¬ĚRw¦'^ŤyYFnuÚ±5dEOZ’űü~ž"n[É‘9Ćč|Y§#á ţÖź’,-´ˇo‘đ7ŚŞĚc.äeF;t"Yfç#×é&|ÖĽý‰úŽy;MLľ¨8+n@Îóٶ‹ÜK#UWkffi;‡:Ý křEÖ¦TgîśÇĐ27Z8®!}ę‹[Ë:xˇ±O lË2ŇZ©Ç»0ÖZsg™…íóśµóYŮ>yB ć„´(‡:ú+[Ć-le9ĘĽt@ŤÖvh‹ '{y§AQYISůYË|%oč°ž^eL¸ú1˝ř>ôyüKű či9`öR«cöţ ĚG›ćťÉ'Śđi/ż1zŞuY·>)Z] Ę‹ăůˇň1cľ¸> stream xś­XwTT×öľ#ÎőZ!ŁŚ&÷b7öŘMâK1bڱ  ĆŇ« u†)ŔtÎT†a*˝‰ ˘‚K”čhڂє—<“hVâKyyy)çúŽo­ßĆŻäż°X‹Ë™söţηżýíË!FŽ 8ΓonŢ,Č<·dáĆü¸Ě´˙łŮěTűôö™ € ,~đŚ ăFžzja0üe"T=ß|’âpv&g­d‹sÓRRóĂ–.Y˛láBü{MXĽ8ěŐEaoÄ%dDyiaqY‰ao,ÚĽ(l‹@„¦…Íd…Ĺ'ĄĆe&‡ ’â’v…EG®ß¶aűÖčm‘Ď.úʍ~˙“ UŻd ÖeŻĎ ĎË/ĆĆż)NHLJNIÝžťy`ÉsK—-_±rŐęékf<żöOsźÝ3Áľ…‹bÄtb+±ŤIDł‰HbED;ťÄ«Ä[Ä:b!±›xŤXO„׉ŤÄ2â b9±‚XIl&¶‰`"„xŠŕ“ÉD(Á'‚)ÄHb*A 1šCĽHŚ#Ć"&O/O«1Ľx3“Ćůr„8č™ űČ#ßć>ÇýŚ$?eŁFP±ŁGŤÎĂŁ;el˸őăŕxĺ„Úź{Bţäâ' ź:ń‡ŕú!őO-{Ş›Çç&mždžôńäŮ“s'ź šÚĘň§ó×ńSůMĐ;­ľź}ě4‡5zy­9 ‡®dąťbť'éĹ4˛>l.Ů@­ĺ‹•ĺůP‚Vŕ˘"Ý­Ŕ‹×ç1g~敤n†䵎/S«ä@J šŻň´/ĆĂh %áLx]_ÎŇŞ|đ¶ŹĂ.ďbĎŔ™ĽPł}ż—kőq~Ćé~Í®ăuÁgőFůU OA±Z%-ˇËä@'—¤yÝ{…VŁ•(Ĺ  ×găíçއ“ĎWËm%Ĺ@¨dRĐČąâ @­Iúô| Ňp=śĐ×˙¦HWTLÖA`q;  |.ĘőÁĹTőĂâăM°‹woďµ×ö& rtţŮ Ä\4§0Cş” 4Ř[­´ĄÁńNĆGź«Öę0 šđPÂM!eY sŔÁŔů¤ _ok611äi¸SŻkO:řřÎaL8ĆcÔ*DmŤUިÜĎáŘË]Îzt°Ŕc1L.žŃ|R ‚˛iŞ3ÚŇ4]´‘‹jČ‹°€ '‘:ĄF†ď¸Ô$>TSen˛ĐMÓ[ fPÁoÍ*Nů–śF“Č30– µ¤ş 4h)FˇşĘÔhˇë>×› ŔÄoýp )ÉÁń·ŕřHś‘”›LJ˛eĆ‘`V…ct Ů``ń7AěGđ+ŢŤ×ĽŻŠ·hZv(˝%PósŃlM€yŽz SŮUŐŰ ¨ĘZŤ@t łµh$yÚaĚkDӭֳͽíGÎ8Ş«-P©ĺ KĺŐ×W{ígˇ“î˙á°ŘBŢ$<”@s „ˇŕ"Ňq_ ^ÉÄ’ďŔt.śŠÄ´VR%梶VĺĽ6Ú,M›ÉiifĘ#Ż*ČŇ)vc§’çýź0ü7C…°É_÷±b8‹îÍ®ŢkŤ´%W€ ˛â ×Óć>lŔ ÚA˝D©Ô–€R*í ÚVŰâ:vnoç4+eI\~eN‹ny´7e‡T—JA(’f¤‰S ăµY@˘@vťŃčpĺ–7¤–íśź.÷¶^Ń{/Đ'Zž'¨@<7|p‹‚زG*’§)+háŢظX@I„–V 0\Ě{°Š{?ŔV?4kI/śbr.Á‰SśĄĚ.ÓŃÉhwŃ˝?!_GÜ]Çbß#n ­Ă@X6L·ZiľŠV‹$[ %ŐşíŻĂF“ `â7‰¬2R ÔŃűŃ+Şü4ëeŔOS´´µY»OŔŃŚ˝XşÜš°(ń„~JµšníąÜŘŠ+°Â¤’Ë5ĄŞ"&iZq4ŘG­>—Ň×Ńáh;DW‰šňŹ€nĐÔâlŞë˛_ę÷(á¦~U?\Đ?9ä>ë…y]Ęî4±¸X€ĘTJz)PQâÔ5=Jâ=Üáě=ň#˛Íâ6;j¦ĽťÜµkÁN4î€?zkEµ™nř¸Ë唳BYTV®S2!“çŠwüĘţŹŕ‹§ŕíŢaQX,»#$?  5…’H Dĺ «3× s!#ż¶ŘQ$’—iéŚĂé& #"¦ˇy™6âzßÉ6c–7Äż΀†cVGŤ×yX±FÂé¨/(>»Ź|3tS9™TMFěÉHTFaC‡Łň°Ą‘Á5im3ÚťnľŰ]WéĆôu¨LY™˘–eU·ńęĺ}]Q I˘ü\:Ű›nKÔ´ ďG§Ĺdwšş«gZ˝€ňVçf¨ĘKu*f?Z'۱_*| Y5ÎZ§ˇ¨ÚâÚÜy„ů=vČĹ >}ćc¦©`ďŻQďŻMK–ćĄÓÇá złÁ,=FŘ>r5ú\‘D@Ɵ勸‰;·\†ö 1ąŤß%y÷ä~GmNÚVŠu¦ÔĹ3ÚŕX¬Q-M+Ta% '°RîUŇŐüHéŃĘ!ą9 Ř!IbÇ“n,lE…ľ} @ĆßtŢň6ű†Ś÷=;exi¨r%şđŐ,4.ÍX ř»t'jÚ+»Úď2¶f»ÔRăĆÍ߇&ćV–3í:ŰŇ…ĹÖa*))Ő*Js™ä9Ň= †Z|5ŁŻÇ[o0ŃÂ9á+ĂA1[T®:hÄĆ%Ä×Tč*(‹Ón‰čIĽ GCîŐăě3ý0ÓĄů6ĎSXS\˘Ti5´Hś.@#0mWß ç‡_ľ¬öh¤vF©.U€<*»VV×V×třüžă룩‰¨KhϤŹ%śm śŐ÷8Ýć,<Ôż]mđŤá ň?ëŽbc†ßôóC¸÷Iha Vř˙µ2Ĺq«t?Tö˙kî]z} ă%Ŕ•Ę#ž?wT\uÔĄ]˝Ż˘‰8ű4+˘6ľ%‡îÝ× Žü{îk ť÷Útů úŮůɧűŐŃP”Ă8ÂvřŕD§÷křý×Aě öŻ;Í»f¦lĂž2Z™n®+‰ ^bŘ»ävô‰ŤĘž·đĺ@­WL¸¨¶<[Q–0'+¦GpíöńOÚh÷ [ݵ÷*ügčݡľ¸–4·V39,ÍfĎQ@™ZĘ5Ť˙#żş¨ˇą±®„_đwŕýKčßŮky0Ť&Yb‰T¬ˇ3şă+ň°dŤB\†č9—·Ýňv9;âjä/"ŕPdĐőF|~ ČÎ/ČÜtôŔŮ—~8ç íđźĽi+w27VŘ{rľÄ=çŚ;2a¸ Ă{ýĺ8ó0Ď,+TÓ’ŮŘ3ËuVG0ŘŰű•M§ ďâ”[{;7GÇçJ‹°jĽř\ę%QđC0Ü#[°É:çľ ·@Pť–‚Ľ˝1č y:bV«Ą…Sv{SO}wNŞîV‚Ů)ý5ýá7'‡üÂö|ďź%RČSĐŠ,YA1 ĘtfgµˇĘyޱ7V8—Ҧ3|Üuöpťúhkß<˝9–' -CÇÝaŃ ·ůśĽćĘĚ‘–$jŠY â±ăĄó%MtČý[wëp6·yýĆôşA_óů١ظǀŢţ*Ęú[0žł˛ˇD®ˇ‹¶%dŔîARQ[á†ît۰;}e¸_l5pň˙´ź&-†ilĐĹě§ĽÁ±ëĽS=ą }“żhí†M€ż'㨯Ęŕ1U3÷ŕoÜ®ˇ#ţó_ănY”üEľđ»żýř÷_šé{>ú@€(¬z‹bŢ#ŠäŞĺR ­ŠÖďÇcęnc‡čMN’ěîᆞęË_“a_ŃPń×ßĚ>÷Óăٲš%póŤîłöa·äĺg™˝Č Ö«¨ŤÖzwoÍ…ú«ŕ Őß·79'-‹V{ ODp@T$Ő6U8~µH[’€V†teŮł‰íľ˝V˝ĺ‚“nüOR_ŞÁ$.HĎI#eňĂýk´F“ľ)Ú«ËbęĄKŔÔln° Ł*ůĽ‚Ű×ev%ŽŹ¸łÍEKPÚ?ýôÜŕ ¸€©ô -EŠź±9űÖgp Ă˙Öw8bé#×1öňĎ5v§—ç7ôjňXŰ#MÚFDĄ+č óŁ4]ˇÓSFÉ-Ĺ-ÎcĆÎ3ô̇Ďqç¤bD¦Awâż°’ë¬#jŔv®ćŐYĹ…Ąx¬§…ëwÇíé Ő^P±®Q®O3žę»ÜtĽŽyNö8•úÇš›hZş…í’ZĄÍUnPWUpÔ?ę»u˝/aÝҵqŢÎDäĆäoŰł;»‹Áˇ´Ęę¬tU{¨‡ŔaiKéŃ⣲c¸džĽ§u †ĺĄ>ćă||žě7ăč>c xmş†O|îĺů{¤•Ҧf“Ícˇ®}UsPýGRbŁ_‘L)͸čťL7ůEͶ”™č©ÄuŻöŘ0 LŤÔcoă‘7ŘŻŘźýüÍ=ß@\q†ÝLě(rŃwŹź¸.ş±}Â_8l•›ç”yÄjĄN«˘ĹJ‘F (YąŢh´÷b7li±źÄł¸Gî 4ĹQRZtĄq/4t•eXc«ňt¶űúúîŔńpýA¸)/,’Ę$jzŢCĘDao ( .)”ŮĹ5V“Ńle<¶Ł ‰ĐUÚ n/©Q%ˇĹˇéň÷ŹłŞÁBwĂĺ–rKą đm?XşŔ˝űHűŕ ç‹ű°×%Ľ;‘·gĄÇŞ ăč“p ‚ˇÁŐ“BÜ”^G ˇžF•ZÄÍ.ٱŇF»˝Ý_j nGܜ髟-^oĽ(cś•Řó»©ĆBwAJqfÂźnîř2p ‚ˇÎĂ®+p ¦ýţÁˇ’w&ĺWĽ!ň€P@wý†Wr~óOŔJ‹Z^¦’ Ą°dnŻiéę(8·`ţ’mŻmĄĂP° -ibţĽçS8 >…ÝůT:Ľś÷ě‚%‹Ö”}ÚQi=©7Ń WoťţPßT¬‘ůó· Ů«×9˛_óŞTž¬B­VVB'íßU’JF_\Wp¨Č“ň@¬zW®®Í˙4hUeE/˘9ˇ*yą¨)?ąęŤćZ}ńŰűíg€uIS¦§¸ ëŕ0ěßż9öą7/ ŤÄ=4·Váhµ4âtşŕR¸ďę§&S…بÜç ľsÓ=RÜďO±Í0ŽŢŰu"şúFő_/€{Ô­MďNGĎ 3×DĽ“r\F/Ë]ćRËnoý’ ź…ăŕ¸ď)lćm~>ňů­;ť»ôáĄ{tČMßŮ;Ht÷§ĄŻ.|y[w>ÂséČ/ďŘçGţ$„§đĐ/ˇ˝04"¶Źg¨0Z1gýŻ ‰rť„btŠÁW/Ő›ě¸MC5Lŕ™ěŘ‚™W&*R¤ZĽ2vŘĘŁe Ë5W`ľőůýĐ‹Ĺîű>óň©Ń$ÄG#Ý5 NěďkŻi¦ăĐčsç9ľ†BG…Ą˛4PőŇęěLQ^âr8Ô~{×wë]úop˘.G¨ fŢň—^śľXů™ó§ďŢżíßí?łNW ŔŮpĄókbĂÝĽÎT §ŁČ p6÷ŇŢ :ńF@ýĹâz,–ŐŹ(O)*ÓĐo!>wÎýc)O©©ťŔÎ\$ŁĐln)O|P…§¸˛üäE@NxdŐŤŐv}ňą?ţďÇwH{čdи‘çßhÎ`p~Q‡áF81fŔ]0drH?»’ĎkĎ­?śš–śUźë=Ňá=Bż„.ńĹmItH]F˘`J«¸ĺ¨÷pçŕĺîřËç;¶(ý3ěOľF?’˛$iŽ>$‡đáÉhŻ3 ”Đč!)ËLĂÍŔI;üű|,dµXéŽĂK<ŕ)µ*,¨&…JmĄ@ (q‘DTä,±h¨Dáč[´9W†E?§®ĚiµÍ6š Ő6‹8řx·-Â̸R\ükŁq“.­Đrę^¸ŕg|7ĂČqUÚĚXF*Ôu9±č$ŠBç¶97vnŁ›âßŮzPÍćş ćń^ěhĽ×v!\’ľźz)÷Xôĺ,·ă> stream xś˝YoăĆůÝČŹ ś‡PXk<÷±h 8Ĺn‹bQ YE± Z˘m&鲷 ôÇ÷›áĘ"­X˘÷€Mqć»ďýaD"l˙úźËÍŮgBr¤¸ŚV©H`& U *Ł2ŤţĺgX„Mtűü†ł›łď`Ѝŕ°NjDaÇHjŚ8Ń `ŽŚfŠGź…X†DďP0®‘¤Ńfé>ŔQµçżg}öČV©ŃšĎÔ`żj¨QQy D'ŹČ˙Xn˘ďg—?d¤˘:ZÜśŐÂ"‘ĐH©#E9ŇFD‹ÍYśT(Oňb›mŇŮâ·łw ‹3†LÉ>Č„H ˝ů§¸ÁX8ÚŤ±ZŔc´cb• H˘úźSLń“95łą V'*&ě-ˇoA¨Ř˙!s,ŕů|öóâź/ĺ”Q0ĐqŹÓYŔ)¨Qp 2±ŃŽSě~cu\_„"ĂxÍę׳9ÁÇźČĎžU#âŽýŃ»\żÁžcšX¦…Ô*¤ĚźhĐž4i˘j:ŢϤ”ÄE9›ň'«Uş˛ŹŘfń˛ČÓ€Z»ĘgV2”h¨Đ l« ŹĹHDŚ`!–řĘ {ĐX0H„šŢ†šŞd]ďÄE8Ä )ű׿ĄK[&ipl¬âUZ-Ëě:­üGDĆIŢüNâ,ߦĄEĺ7přÄţN\ĺä\Î?1őUîĘ4XiŚŠŻżřwšĹŰĎ…“Ü J(áŐ.›ŤSʰɱÓ4űجĐlÎ$DM㤮t|™x{ţUYm›'ył›š§*ŕöY>€˝k8Pąrîńr“ŘąmµM\yj§eĚݮ܅ň4_5K•'NZ“×q•BąŰľ¤ž<E÷W¦í2ßr/AŘšÄW«U¶ÍŠK‘†Ň“ô¸Ťß_}řřI”0$Uź“źf>B±`— ýŽ«ł8C`lO!”`˛^ô©V(°ĺťŹ×m›Wť“´÷Dzěk§¸ń/°ěC”›n)\Ż—ţwą~¨ŰG·[?':Î Kiúg•ÉÁ•5ôýʤ2-ÍQĚU‰Ď% SBýi} * &Fm8·xźx ‡…úőµ¸]·,[q×™’Fý~A¸|>µAĽf …pĂHj Pč}±ÍlÝÎ łAŽµÖłtyĚŇ (›—"ľN»w_«mů°Ü:}ĺv† Íů|xÄ ő„•ô°Â¸DZš>+µXÜú€Đ šT/Ä=šÔŠ-jmă©+H –'[!­Ř $o™čľ|‡äémDłc_”Ok”7e±±öĹś¨“QfµD ţűăĺ]R&€¬ÜĎm‹Úf=ÁT5Đ™ĺ·.OÖî°¨MÝ0ÜżµĎÜ…;RJ¶žT-ă‡Ęe0˙Ö{ s[ťS?Ř€S«Óó÷«çŹőčTqC›@ů–N‰ŃőÚO.wC é×~ÓŃSe·yCym=+Z÷‰»Noł<÷¬Ő[{$Öq×Bˇ`~EÔźŻŔ¬¶i÷Ö…t·Ť„8ş0±?şř’Íë éćv¤ˇÄ>4%Ť{půůÂÇ!p‹2­îÁRłÇÔU45 Í{C›î†ýibťI]iÝß}iŔj¨Cn’‡őö˘ŰęĚÜ˝ea®ńsĹ»¤2Ú*®cŁM×îYŤp© r‡lŕíJ2©ˇ¶íôÂ(‡Ćgd(9Ľcg( ÁÂD;”$¶Ć’ň ˇä’©†’ u.d8hňÇ‘€ňÄ“€Ő§ř|NÁ–l÷Űuý˘=vćJ~đŻôó/˙)Ęß›74ž˙µé¤e\â,ńÖŽjŘ0¬7GMXDŰľ')pđeŢÜěť)bmŹ3ü@ÖÔmŘ~É-(®V/s”lz!ď Ĺ{!°ĆĚâżĚ§™ťL\/ŕŽO19ă zŃ;•ĂHDxGzçOýEŕ/GÍ´6;<;‡2˛>čiNěq»4í2Ą¶Ë™\Á Â.a'Wpvjw¨Zď b“+8ä9Śa¤2)Ő<í^Ş5 $A+€…ÖŻŽ5M°ˇÖ0ŻŔOś)ÔĘč> _7¸Ť›6áÖ^a•-…ľ}‘şź G"Äp¨;ˇW©ť ‹ÚąöĆű7GÇ{ż|"gmÔÎ\Osj­wP”~q,WřĄFË«Z‘G§˙ýgbîJ ѵc‘—łQ‰T!Č‹#ý~4¤:ŃQ:Ą¨@3†–ŃŽµ^*)­m† !N]ćAë4ä‡á2o·éÝĆíÉż'÷jąL«Ş(Ű[)ĚNşŽ5YŻ»Nó¦x(»®pYlî‹<Í·UĐŇŢ„Ťçޡ‰$iŐ3Ú‘ŃçH0Ş#?Rđ3 }ďňĚ}Y˘Ú âĆ­śmOv„”ýđ&ý:R¶wЉż?Ń&µW•˛˛cÍn¤yĽ5‡Ŕ_I΂!ĘÍś]5­H9A`a;†{*‘Ŕ_I¤Ô [i ‹´.ß'˝âCŚ˝ ßŐC™ŘËč ‘î-řěĐŘ^ÜAď=ü´gËśé &k°ď©Ëěť ÉTż.ë2˛ŕ~s™Ţ—ib}č Űţş˝CÝ>TŮć~ť"ĹCŢ‚ĺ˝ÂŇXß@©.ş‹ĎwŮň®«D7I‹‡Ô'ţ¬¸Ď:|“§·‰=»Ů{ş!!o©đjµ]¨ÎI3|8‰]„LLlĆ~€ŹMXZÖ¦µ Ě06UĽˇOl!Ş&‰ŕ0e"ţ‹–=~¦ţ“FXŤM:÷1yŘtÚDö+Ó˙ö˘„ëIP]}ŘFýČ€őÖcÄ1ő3řˇRŤŐ¦7fŹlv—ý˛x‡ýS|·ÝŢWo//—ĺŚXÁŰ+§9*çłą&ö”Č+PQŢ^Ţ'K÷*‚iü{r›~ŰŢI9ě„m/EŰ/K÷z·ZĄëë™ýRµĆ"~H·ŰtíĆ %âŹŮúqV_qZmK{#ÇĆg)ßźýC7:endstream endobj 68 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 275 >> stream xścd`ab`dd”ńM,ÉpI-ÎLĎÓuöĐ JM/ÍI,Ň 1Ô54Éküfü!ĂôC–ąűwŔO“źX»y»yXzx8V}ź"ôÝOđ»'˙wWfFFCźHŤdM#…€ÄŇ…€ĚäŚÄҢÔÄR…ŇĽ”Ô"…’ŚT…ô‚…śĚäÔĽäT=„í Î PŰB  PĆŔŔŔ¤­ĎŔŔö‰EĂáWßĎśďÓŽ3~tśůűŁďÓDŻ:ţ}Ő÷UÇ ˙ß«~Żň_ÉÎ÷Łçw@ŮŻÄrĆ!?'ú°ýľűχő_Ó”ĄSż{ĚfŰĘuŹ[Ž‹q†>g7÷Öą<<Çńđ20©«hőendstream endobj 69 0 obj << /Filter /FlateDecode /Length 3591 >> stream xśĹ[moăĆţ.äGWĄjkĂ}ß=4®@Ň6Z$g´.A@K´ÍT"’˛ĎEţEű;űF.u˘ěłĚKâ%rwfvfvvćŮń/óáyjţ÷żWŰYŠRÍURI8×đA(Ιś×׳_fŘNű_«íüĎł/ľ×s…TŠ1›_\Í1<çIŞů\†üľŘÎ’2+«ŰĽ.Ş5Z\ü<űęböÝ,ťŹĆx®JÂ)ŇĘÓĆ)C8ĹÚo Ĺ/ľ'fŠ’¨XŚ ZŹăfŽ2 Ęâąď’ęňç|Ő.–DJ¤5Ięü¶Î›Ľl˙L‰¤˝ÉÍ…Ň”%«l“—ë¬îźTöł€é,ůďĺ®)ĘĽiţHŠä®ČďĂhťTWýçĚĶôö¶j¬·Ů'~K g=çfčó6«[ëÂůąo-ܸaĆuśÉüĐm[ƶBŔÄá¸^ŘÝÖ•ťŔŻÚÜHÁ7YË­XĘ­§´qô Á‡#Ęëe›=„ýIŔ3ďň°§eRÝ‚VŠ6<E5ĹuŮ Kôy9E:˛_/„ٰMl„ćFNbbç]^9DPŁ.ťgŮ0g†€łĂ¦­w«¶ź|Ę6{oľ;_Ě6›ęľ±ďÁĄóUqőŕ|•c»…ň¬öŻť†íĽä>Ď˙ÝtŚurąkĂ;ä‚ŔˇĘt—×.ŮŃÜĹ îö3Ě,‚°đµ;Ĺ\|>h†‘ FFSEŮkĽs#Ň}T4ĘWÖŤśîí‘˙ËŚcŤ8?WiŠ”ó”rÄɜۓ„Îë|ţŻyi,%™H5¤ŹĎ]yŇAąÔ ’h¶Ôś3X ĚL´–l~<ĐźúËSxĽ5 ¶I’6I'ščŁIć‡bgP,ć‚`¤¨‹DY†áâŃ”ř0H:L˘R m 8@Çźń{‰óR –âI‰Ďo-ŹŹqĽÎµĆŐ2eŢônđÇĺ4GŁČÂ1ë—ËŞč„ iO•U… b5]VE)F\î-lqbx}$u1,ąÜÇčp‚‰ _×@6&˙u˝Él$®ĹŃČ7q6´Rě«ÔŔt§T.˝Ź‰…2ČN„«q…ŞiőÉ0ői>v8ć Š• qx#.źH±RoNŹ(ö±Jć™WŘ,çđUŁ çwĎŰ܎݉QąŐsóŚ4Á@¬gĂ8Ô ębʉcă€j‹_˛¤É;Qďó6° < še›×Ťí‚}ťDXÂ~‚¤%ž{~ôdÓC^»Ň»ŕ>ÄÔYÚăy 9‰Ŕ˛RĆS@=ëâęę1föÔ"C5»ĚČŞw™‘×5 0qjńôęę*Żí«N ]ç=\×U]í:0Z'7@căQ_~Z ÔľeI›C˛Vg›ž‚5Ń<  ŢwFpTŞ˝říĂmŢXDÓÝ>ĽYŻ ăŮfc®?„ĹŃĎń IL÷1?édÂ&iŞ lŻzáĘţ%,¦ük,»¶g™ţŚčěŚM1>…™{ÂS[ąăF^ş(Kŕç#Ă~KśşQg/cähÍÓBŞ4…\‡~X]>ű.Ř{CGöX ’•ó 2jÜ9ăpŃQˇŹŔU‘}/¬ĺŚńŽGbśî _ö]w&łu]wK±|Fđ÷ľµÇňlZ “HŚSC¸č™ˇLĚeLó7ň®SňGDyŐS=B<ć}ć¨GČŹc©Ž°śÎ#L#ř>*ôÜ2Ŕ—ŐßČ'E"=v[đ ź8TΞ%–ŁŰţYn8ŕC'÷˝—Gů±P(ßůşC }wµ ť®ąú~ř·iÓ¦ęOŢÔE{łÍŰb…ż˙Řf”’ŕ˦µ,U­`„±. hęđé¦ÍL#˙Ú> stream xśÍkoÇń»~ˇ|96Özß!ŕşnĐÂ-XAQ8Ap"O’'OrôÇwöu·K‘'ŮäąEXw·;ŻťŮyě,ßO0"l˙ ˙ÎV'ďO„äHq9‘ŚDÉD`& ‚±AśMšjňŻÉú#ٰ™\?aĆÉŐÉ÷4ETp;P"Ea ÇHH24‚ćČh¦řä ‘ĚÉwŸF’OVĐ.á ĆŞoâ¬ĺÉ[ J,¸Ć™"5üZűWs „'•Iřg¶šüůâäůTL 2RQ=ą¸:ń"n5RDꉢi#&«“wĹW_MĎĽ0Fóňărq}ÓĆ7ŦĽ_¬Żă#-ÚĹŞŠOĽh›r˝Y´‹z}>ýůâď'Ż/Ĺ„­J ‘Ŕ‚jÔÁd`B‘aÜ\Ü.ď6Ó‹_˛É€ Č.Ę€p5Ď@ţTôŹH˝)kP»UąAër];9~>„SÄ9ÝĎŽvXVlśŇŁÍ ÎěAĄT"Eő®8Ąâ3Ěΰ Ú UAč9fçTŤń9Ƨ‰F|2TkxIrţ¦ĎFY%†9’r×"ÝV͢ž°LLQ$µúËÄ”˛ŰRŠé”ĚO!Ţh¤ĹĐŹzN8"§ţĺ Ä?+źż©7żĽ\_WËjs;VK93[ě$ÜŚ±ĎbëzhŘg§g \Ľ#?ÇTťé BRów?• -Ö6Qöů]SÚťü]‰)DARčŁíJ~LQťR~¶žx0ŕ©UÎBŞ%šD-‘ đǧ/­€uĚp˛'O0Ĺd:}N8yc•ś "̀ΝEÎRĄĂ†Sćt<łpR•Z°€¦qťŔCľö»boF@5-ltâtoŢ™"|ç°ĽXŐ›vů1ŽçĹ‚uÚ_Ő͇˛™Ç¤¨~źU·­¶€WĺǡđĆ;îâ@e* k‹űriŰźO·)PĘ燛Ĺě&rċŦç¨nćUSÍű—ăߦX´›~Ö¦-›vęný0¤yLwTǸ|?Őa»Ż$3ßhz&±´ą`ń·+ CGÔeÝŢÄ'驲T —5†ĺ>x®Ţß•Ëgđ¬üಇ2›B‰„¤ĹT˝¨§@aX' Á¦ý#Č`VŻŞM˙ő˛‚…¬PXÖríżŮżA•Öqdžc8%z›!KŚBĘâfPÂśQÄh.áŤĂ4¬Ňkp\™x3Iµ7ńňŃMąŞ:©iűÍqÂ\6kGZ­řŘÖ c“mĺáĎ:ËťžQí'ß”·@ě&ľĐE÷QOŐVőDQ­çöÁĘUőU˙!âß»qiŁŢ„”!Lą °rŘk3.žĚDVńµZX]ň$ĆÜÔM[5ţ…Ő‹Ĺ­©†ąĚ ĂĄüń9jN”CmYC\ŢôĎőşBĂJˇŔHŔ‰młÜgZL ŞA˛ąőĺŻŐ¬uĺ€mËJď ˘™×@$dţ°Ý|Ăß°B7ĺ}źśÍ…A«Ş\®î–ýW·ýxɸ7Ö†ćq†S‰&J PÁMµ*ëđ &y·[ęťR_Äâ‚J[aęJR„kËďţ"Öţ[E,n˝"NŠXÄZČ“jX8ŢŽ”śŘl„–iśťÉçĆX`h°䱂,J@\$Eő®8ýÚçyR˝X/°źŰ’ ŽoLńăĹ«ľwöm˙w7ť÷ĺ–ťÓĎ*»p j˘i.§#g?!ŐOQ|3JÔ }‚3$©8¦:…<7…·ˇŠ#Nxq¤†ŞXŇIQ# ůä^ŽY”°ŕ9]3Uß:u@hGA…™Čy9¸sj.&‘d93—_+ĎWP iăH·!/ęf ‚j*ľÄĘŮ>P,ÔÖĘářśiŘtµü"+ć ĽůŠ-«őu{ę»öĹ‘Ň{†'yľ*ě q)‘V[;ĚČé “ŕ-őP‡AoµNŕ˙ĐşCl Bú!f{Č@šóŽí@Âđ.ŁŐ>Ä,ࡏĺŔŁĄÇö Şcz‡}ŚŕTăx‡”—±˝C‚ëĽĂáÍ·ÔîćK¬{&W‘C»oąÉł/˛RĚF°4'Ż`ëÇ:ß ň n“Íuy$Ż A9Ď7ĹöŹŁh·•+íéë»ĚáůČqęőa=аEŞ­­llGĘ’XŤďHÍ“)@ lŹ#ýtyA«˘ˇ"âŞTŢoÎĆńÔńP0A}¬Óm_OŹĺî$CL±\|±WÂéa;ô›‡Ů~¸H‡xxí‚N•Ëa:JŕŇ©‘HI_Rşmëö€UŚwŹR#Ĺ]€Ć2T‡ŤţPšmoőzś Ţź›ĺř†B•XŻ:Z¬B!đ#Rí_­ăeDeNÉę ŇN‘śö±bJ©Î×éřJŚćR,‡*ľH‘S=R Ç ˘:7ú±"&lżsľi/R !×—Đ)ré/"´Î©Ś"4a“[{ţČáU i<Ô©q<>X5ˇQň%y%ĎQ’Ąm%/Jńi(Ĺ>”ź~DÖ6H˘AY)eňĐ?˙Ďşµ§%ö Ö5É—Ă—#¶ť,…ńx—vÓŮ9~wŕg±SRĚꦩfö0‹ű ˇWÝ>S4Őć6|VîÜÚťş#dĂĐpčľŃbV.gwK#Ćßą ިîÝ–¤|îOÂěĆ]1đ8IqSß5öîŚ'Q: í¦˙ţÁözG–üQ§I’ń; )±tJ=›Ý5›x¤ĄŠ«¦^Ĺ3-’4Ł®CSyŕÚÍ1E}uµ©’s ĚđµLNď:žÂ™Ů|qu\„FŰÉz˙§Ŕ¶ čܔ˫)±XBFŤN©ŮyhG°˝eÄ»ó1cŹůŤ8µŰ?cëŘRⱝ!Üžâ=ĺÔnÇXÇvDk$„:jŠÂ3Eŕ"Cuśá [ZSTGú‡Đ’¶—‰#ćÚÖOłl±ÝĎ8`iIÁ)=SoąY”Ď_ŐËzuY”S3a;HrIŽÖu«¦$HO>^~ć“ăćtţ&9É+§s7py†ęÔE‡ž„ĆĂŚ‡± vWÉäHÉ]gr ~P+w°«ŢČň5‘ŠŹš§Ä¨×iľ ~_<>–RuŽś»"ă&wťKJpMhńĘ@ |ěÜŽPřC ĺv˝˙¸năk,·J÷ý– yzé>@IńBâqÎFľýoďüňř3˙ž*Ű1ČLQ•ÍTZ'Ň]ʵ?ÍchńŹzíccéĽj;ÖlVô—rJŚíFŐĹGGńâs»…ă…YbŹy ËÉü±],!A©ÂÍfŰĹWö×{iÖĚÜeâ+×^Ş©Kę˶\¬Ăaę(][ž»ĚŠőť˙Őžeř L_•m‡c?¦{0öÇÜäpošů|Ł!‹Uő[˙ čŕýbę•Hv‰ë/,žGnCđ®ąČ…e·Ąm˛<Łpf Áo©¸¬e°ź®aŃÎ^EUP.űy„+‚íőU™Âól­vł•Ňboú2B2Z<[Ž}a”€¸AV s`†)Łîwcô6eŰÉÜ&)•¤řh-,Ś3ŹiËŻÜÍ"”aÝŻj ŃsvĺM:;)®¶đ0¨«°“SňPxű‚˘#‹ŰîtMs˛\{;v6óĂ”Ů=FŔV´ŞV—U“ʱlă“ Íâö¶AđÂ"T*B@cgˇ ±Żëř]ŻXW÷ľQűhë&6%“–y¬GÝWOHxä®AG˝í9!ŕ3ę˝9şTM˙Y|G}ŮŘ żŕŘŚ?đ,˛ú¸\FvcőČ=đâęn= ?Ĺâ_×Ua©ĐĹlÜ匮Y9`Oš˝{€ĚÄž ae2«!r*'Ŕ+őë>‚ą°l> stream xśĹ\{oäĆ‘˙_ȇčţˇ`‰î÷ø°ąsw1ě•ÖA@ÍPł#R&9’7Č÷đ×Mő‹ěžť­—¤‚]@3Ăf˝şę×ŐŐEţ´B9^!óĎ˙]?śˇŐÝŮOgŘţşňÖ«ß]ź}ů=Ć+ťsˇäęúö çI7jĹq.©ć+IX®ŕďőĂŮ»¬ŻĘ‹+"e®Uöʦö_VY[ţ´«Úrc~Qđ Ën›6\fY_uá’ĚÖÍĂă®/ú ”kŤ„˘YŐÔůĹ~PŮźšľG÷÷0ľ ŕ*ŕŰ BőSY÷p·7|µ’ăh„t¶)>ř+šdÍm§4źËňýxɉm®č¬L00ŢŐ˝ż"uvŰ6ăEäe'YßÁq&.íĎŮsŐߏż˘‹ż^˙ń ď[“\Sć¬~[l·U}çj0–ÓVY™Ţîj٦ T$YnÉ}}}öL9Ç:W0µ\p•«G”眬0•,'zŐ–«ż¬ę3ÉŇŕ%/Ţpvë ËÜ ăDNAlÄPÎÍ8ť3#¬d«g`!€–Ć«?|‹·–Ĺaw%Ć]µDY V[)+ˇqNóUŚ8Ęţój´ DŃJQ˘8ŃDĐ'‚„âŞQ®–1׬čňş¨'×÷źŕó\É=¸h©Ă~12;óP¶ŐşřňOĺóßţżißOň‚sˇH˘ĚŇţŔ@Á(Çý,ě‚«Ń!frî+xDÄíüÍ­ó˘j››j’C`ś“=#-îPq%O!^Ř%̉0⡩!Ĺťâ,•Đ]Đ%(Éa““p;˙¦ŢTEýĺ÷宆˝Ĺ4—9c:Ufa—ŕšçB.±°GpE!#âŁG|(‹vé.1·ó7dß´ďw}7mÍ@(—<Ődiw°«düÔšŠ=iŘ~X— ’pkUˇ¸‘ë„z:Ř2łDżˇĺŚ"ú í÷°yŢŘ-%Ô–ľ},ŰÂlă»üÓ¶űu ćŽt@¸%ü®Íöüt•Ůí®^[N–Ńńi2űwÓqž|»mëĘÇe0›c˝řޢ޸›Žm!ěř°[—•ÝűźdHażHö•.Z«4¶eǶyŞ6¦:cĚ€°ČŞÚ_Ĺ2kÚMŮŽ2E ÷n,Űۦ}÷á¬çÎŇN‡µµ*|Qű@Á·Ő ŰM‰ykĘ1D –ëŞóe ®€ÍŢÔ'ç3žkÄbŇ JuŞ}l®H$ ů»5v*ŇÝ5Â]•ĺÖI§UÖx,O» ú,!™Ĺ…€ă !h -f]ÔŁ7ĺ Góh<·Řn?„Ë"ëÁpż±…7kJćŠNć31U®[3µ„H;Ó·»ív´ůÖé¶ ?`ý4&ľ*f/ɬ-PYŻËő*ެnľ|°ľoşŇ–¨´•Çä”ő_j3_ÄŕL.čŤ;łŹ ©€xăÎŢ šë(‡Â›őyóĹ`J±íBő X…Jśč¦oʶë›f®s®>7Ýc°ňç>Tą/" cOĺşoÚ.”íĹS>Cą€•€Ĺ*žň™Ř: ÖCb&¶Nsów  ÉěůľlËQÖH2†[Đ”e›ň7uŮŤCŠĘšěÍ6źő ç][Ă)lIT`žö©ŘšöőÍ0gfL´2MzäđZ#뉱‘-{cŰâ1řó}i­-µŤ…ęÖÄÔYŢ}L|E»Š¸Bń‡Ý¶ŻíĚXR!0t<¬{gáĹŔ«ÜlëßÜú+ V×\‰i¬‘ŠV§Âŕ<ČúĂ}ńřÇ Ąv'Ó=ę 4ATp—n$şol ů›ôp·ÚX-höű a*ĄJg#ŢMë®/ŔC/G«[3ŰË:Ȥ-bņ¶‘,śš±b”ţľŮµÝ/Ĺx-ťłP7 a~¶g żDL“Ľ‰Ź–Nź ¸Sm×*Hu»ő}ŕ$¦gĎîŕĹ,ş‘  ˛74ä©{†6çŘÚĆŻąŤĹPF-č8Ü/šIŻü`'µ–w'%ŘZě2D.ŤAňQfaözs–Uy™BbŘ]a…á‰5©őş`Mj‘ćĆŻ_fIÝř4fżą3.§‚ťŢń+ş Ă?Erź1 Z2›`z.,Ćć,ŤŮă°oë ]*ißśŐ lęÍ@Ö»'·p‘Ţár+?Žß<’ě1ČÂ÷KDůóă¶ZW˝MZ”3JHZlśs—µxĄW]42/ťűěr’Ş ddKÍ®ô$0…`Ť Ěž‘YŁ€ }ń~ŕ OŰ|†@…eŔˇ;µGŹMe3B;„µĹŤö¸Ä,HŤ‰Ěőîp`2 Ş˛ń.’ŔU‰zÔeQ¶á‰öößťćÜŢÔ•ýÁDŚQs\+ÜyGspËa648ŻŮů]!sNzTFčW\~…Ô÷aEÝaäű!ŃÇS»€ÉŇŁY+b—.ş@pXDąq ńŹ~ÂŘ <@Źm# KwůŕŮ(@攑ÄäŐěÄŮčŃöÎFaL gŁ„@‚OŐ'ťŤgńvˇ‚ ðeĹüŔ6wZ /¦›ś`Χ‚Iؤ¦ «™Ža…Î)$čG•±äĘUb/{ »śr° e\©Ě5nsS{ć8át–r (ÂS…/¦žĎľ0m¦´Ç“iŰě\-hĘÔiŃŘ3˘ľÔÔiQ¬VçČ–›iRµP(Č6Sâ?^,]0¤Ęp˛ †Î3Żc‡üÂ*˝lmŮlß=\"ű\oČF$%˝Z’pĽŐLh«ť"ÇuŃăMÂV˙°‚Đ § /VaÖ„9č%3•?‰/4sŮ’bÂj>¬2Í_,%ţ XĹ)Ŕ爫ĂXĹ^«dÎzö¬*"»pRqš7§:¦Âü)ŐČé żčéĐaĆL”\™(Á9xʼn«Śź«dŇW*Č5r*%Α톟Ż)CÍ杇#¬”‰Ä¬–j7d¦µXăÄZ» aŹ ëO µ0ncÓq˛‘iÄm¬ś3Ľ f#Ó<ˇÉ/#ŇKç—«yóËc:,_ެ^ş}ßm˘ćRŘmşÄ$94WÓÁ[›HÖŻ1] ŔCŃTŤyŕ›Ë|/ oIrĹUÂk1üV*ç\¦öš ŕĺ’ŕ=[-‹ŕD›3úSŤ‡CČŞë°Éx 'cJ%fO»cş çÝ1«yďŁJĚźyG¬>ż?nĎžć’ÚŇ@˘óÂőL ĄźĚýŇ“^xéŤYťă‡i ʦćŔRé‚ńĐóZě©÷0Hb©9.pŮŢłŰÂÎ ű/uŠš(Fř±W„tJsŤčIyLz᤾DP÷8ÄńλăwěµŢŤmëť ć`Z|Rë]¸őařfÜlµ=ăÜ<çŤüîÚNxy F| _-©6?ŹëóŇ/0‰8g]ůÓôBYLpáBYĚjŽý”ĘQ ć|óŠ˙R «a?…Č“ËçtAR§ş,•Ąű>µ×͇ßzHgçBí¸°Bů5ćÍ5I¦N~Ž7“¶° !_e¦ÜY{ęá۲ľëďóf×Gű*3>W˝âËÓ`CR#4ĺ,ČźŻÇ—< J'cŮŁ =_šĺ(hĎ— ˝+XNsฺ2ʏÁm ˙¦+ŤXlĄÜC@˛Ňö×LHŰ?Ż)ä;0Y1áÍ까o„C”Ýž+hB‰-¦Ž#=<]p@°}Q߯_6}Ů)fńŐ\âű:SL{Ṙ“ŕBË—IG2ŻäÄňÖŻőőÜBęş“kAG [$&Ľ®ż˙áëIťéîMnÇ&gNéÝ«ÜbNżóżo§HO¸ŹL]+ôŞ^™SSťó8ÉNÚ-Ďň9ą0•6@L É!KúĂĂžkbjS^*9÷©mĚjJ¤`a:vńqŃgĚĘ=ÂG¬Ţeç_ y9§Ě´Ť+çŐŤź‡Áѡ ţb–gsb,ôúoiR8şoük,€—°Ŕ(ײŕt%r,Ě~ną2}0¦«+Ęs ›kÁ_o6ĺöćöőZ*žíĘľ/·—ľŽ,Iö¶Ú>]8iyVv}{ÚšéIVBaČAÇ]¦/PÓěĎŐ]mhÁpó2)D˛ú˘ŠŽ…bć §ŻüŁ“t‚‘í¶†‘™JQś|9V¸‡÷óě+ĘyÝ?Í l­-®`JĄ=׌óÝŮż§cű‹endstream endobj 72 0 obj << /Filter /FlateDecode /Length 3179 >> stream xś˝[ëŽŰĆţ[yÁĹÂŁĆĎý˛h~´©Ó ‰$­$\‰»Ë„eŠÚÍ}‹ö{f8ĽiIem‰N [‡ç6çúqôvJ0ť÷řwąžĽťH%°jŞ8·Ń©$\bɦ”‹źćńô›éfB°…UÄNožđÄäzňĄ'Í0“Â-TX3X(–RŠ-«H l ×bzLłtúך‰ćÂ`%¦ëGlSř†ĚtĎ7ŐSéä5HB@č·ęUꆖëéź“—_Ác[Ą™™.®'Ą]@%5UfŞ™ŔĆĘéb=A«âM˛úe¶řiňjábC‰¬Éˇ>Lóa>Töń±sˇl‡ĎE˛ąh¸Ľłč”Q°1íLî˘ôű–ä`¦ ą„=3đđźŽhŔz5¨-E¶\8voĐďgs*¨–Čl.AkşŁł9#XtÇfß/ţ1q~ ¨ž.>ź,ţP>G$Aô˛yŠFćD̉\ré˙|ě˙.ׂäHT«-úěOźż~Ő&ň4ë#­IËđŘ⫯K˛mZĽŹ–¤ĄúÄlÓ=ôčcµ%“@Ž"*šĺýeÁÇĘÖŹj«ú=Ö¶&¦ú¤űM§¦Î©Ą2Ú9q™!8š2i§ ü›»ŰÎŃľŢĹŕS†Ă:Оk÷¸†Š[CŔ…Dy¶ß¬’ÍMőŤA×űͲH˛Í®üʉÖŃĎq¸$Tˇ¤¨k´Ív»ä* ­ňYC}ç×YľË-Šnnňř&ŞÉ;sH”mĽţCQË #SmíĐ**"\DŽ1„îÓČżś&ŮěŠhł¬u­÷E’&»`é…OŠ]%¸=ďA—}ZĆOŕ’2eSĺ’; ÄĽ›nçWĎáim˝É30DTdyŻž†aî3Ít±š «‡Ť(ÁB©°â˛ÎVM…‚Ś"0M˝1B€HG*Ôđ R¬eSˇŚmé“*Ô&Ż=“÷)<ŇŔMĐĄÜĘ&‹JôÇy+0eÖ8?ŔĚ >Hf™Őď_ŠZśŃ.~{J%‚L„ěPüµĘĐů„§TAŮď E;Ľ‰6Y‘¬ăS”Đn‡•ŕP9Ą—2±ľ–B0ŮŁĄt€’¦Ý˝V¦Z>'&ř$¤Żź>{Z:íçÄŔíµU]Ąf/FŮŘ,xťgk\WI¤ţ[ĂK ě %çŰá«§<óÎ Ĺg­±Ćóşzř$¤ćîfB°F„ä¶oµĎ}•;a ™Oú¶#ÂH[Č@MX‡Ő3׳Ph[žť˘t&„wU}7s]» *đéĽîFWŕ9«˘iŤFOçJ:Çěi(Ţ7! Ť•+•-Âßą5’“ú¤Č:ě˘OZň»q6LbďN˘LrÓ!NĎ;áQ ]‚Kę-—ă$Z} NiĽą)nOqnN± ôńn×.N5Ă RዿyŃô,búD/ďŻôrpF nŮś˘umz“S*Qő nŮIaŔ°€.ŻĹů X&rv©5ç>źŽßµë¶4wIů‡e M>´ř'ěą„fťwT;O„ř-LÚ×»óUî:|Ru”§IP &Ú¬žUŽÇ§TA-Öć`CŔĎF†t$¸8‰¬†t đ†~ßÄőłÝţj×ŐŚˇÍ~çÉňŮc…CBX×QçTj×<•y:<†‚\+üu€FÂc,0q–Ł?%5ŐŹŘPC±<†&=F€<=ĘĐ$QŃ;ű”DL?Kú<†z€FgęŁňă)©¨!ڇőQŃýT­RS±]3Cżt`f3@ĐôdĽ×ζ‡ %&bş6t1bă>éqͤOĘČßč<,|ŃIE'Ä óv¸·Ŕ"Źżo¶{:ÁĽäŕ”hłrĐTZŠţą/Z7ú,Ë×Q;5Ř€Ä%](Ô…`ÁzĚšC±ÚP„߇¨bUĹu ҇U,$‡…CŰ8ă®˙@I©gHĄś1oö,čQ^St]ęžµh_Gű´zľp@[y“˘˙^ük~ëŃşůĹz~±Z\üíňâ‹Ë‹Wßľľxőë˙*şÝßĆyÜ\µ| ĐŹß>//¬h·Ť—ÉG$«DŞÇş‹ňÄwËÎbsȆF[—[\Łď*΂„äŢÉZ%7_+Mať¶Ő­d*ŃA·M»x™•¶r ę»Ú‡Á#©kľ,úć6Ţ4ś6Yó|vçyRbśţ>Ś˘ŤmKS&»j=;´‰WЧp®Ľ´Ú˛f—¸ç{ź¤iĐ Lźl–é~U-‡ Ď6éCó°ŁÔÁ+W‡ěĄIxAÇi|m‚G{mjG-żAŰvf犉0Vö+oWŻżPč.^ÍM ·Y0Ö+ź'7·Ĺ|­VńŞú–˘_ă<ŰU—઻†âî6»ŻYkPşZ¦şśŻł4ÍîKL5ÜŹ‰ÖŰ4ľl­Á0™ Đ.ËÖ;3âsđÖAS¦ZďظpĹSĚaŻĎÜëU­‡±‚ńŢ~úţí‘ ©˘#áŚŐTÝfu&śšnK̰gÄa¨ V%Eü© "8sřďă“[X.ľ~°Ga„ŻĺPôÂu¤íŃ»Ňv”ą­ŤhŘRsćh;Z¬ÎCJŚ-V˝@?{´Ő=ŰŻŞĂ|r8˝?H¸Ůź[uŢ(h9 Ú¬ÎJś? Ú¬†ĽA¸“5gŚ‚ŽzăG¦XpůQz@ -Î-˘cB‹Ő™aH‰ˇĹęChcĎmőơa8ŕď-˝O‚Ş“<ĚŤŮUmúK\DIę0^Ž´î4Ź.ŹŘ„‰‹ůůłškÝBwě§á—%P\®=˘Ľ~FÉě. ÷SŰŐCu“WÄ1…VŮrżŽ7E›š©OŢ^_ łß¬â<}óGź~şřwC-M®ň(h–ßVáÖą®·Ę±Ŕ0ŁtŻoe׊ßÜ&E%ťőĐK ]€łąWCíw4č ęăüI.<$‚Îük\Ű[¬NŇĐ,$§ňÎ=O’™1꼯!ú"o6ç„z¨ŕţ6YŢ–—n=lBÜZŤVń6Íś#ů»ŕHgr÷ŤEwIni[! Šm‹ä`±9ĐWËíÖ{PĎé¨Ff-†ďj°Ť–?G7q%·FÝWn§m„?ţеzµZĹéŐ>.Š8=iC@4H0˛CüĹŮ|ČÁ"Zëóú€P@|ĎćB‡Ń¤Îo+‘:ď]´‹ÔćѸ©ónć]Îmť»U° *&ţP.é’tK`aÉóţÍö@bĺ‡ŰÓ˛…ilĘěwńŞ#ĄFc˘CźęĎ–XhĐ>®đHŢŚý"ČTţLf aęPAKü“{Ă—ě_W„aźeV )c ®`[çd5Š–YžÇË"}č?uiÄ48#…Ňś˛ěű‰Áŕ‡?1¨ř“…ź†~VŹ6ż0 R’Ň­ß<ţ¦z* #ĄJcEĎŮQ‡ó^-Âc5Ôá7 §ú¸ś~ĆŚÄĹ©ę¨4r MÝhaŹ´ĐŤ˘‡ďG!©ŕX™łbҕô(Źí1 «ŽË¸—ÇŚ·ŢĎŞÓ}Çsˇ]íĆvS;Çő¨üAśÇ1Qg˛*çiQŰyVýÎiĺ>âLg¨uWż±Ý‡hlȱ9˝J‚ i„#˙´)ŹěB-VC.ÄxsFäd'Ň#u5ى Ç˝«UoĆu"í~ĘGđˇá‘]¨á4ěAÜŁiÁŹČéÉŤ­íh9+g;uÇ^‰¶n=4ę !§sč§Áŕ~¸Qa¸áí•î`ľ;kXÎ?˙y÷yĽK-Č Ó1użĺ°)$”ÁۢŘî._ľ\ć3`J8uŔÎçł9 ˘Ű<ű  śĺ7/·ŃrĆ|0ä°ŽOj÷xŮ+‘„ąś±Ž@%˛1s¦ ‘¨„8^„ĂXZ˘×Iz7ó ,ÄJĽ+rw„ŃMĘ %Ť(_Nţpč'^endstream endobj 73 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 335 >> stream xścd`ab`ddôńőÍĎË74Đ JM/ÍI, Şüfü!ĂôC–ą»űűńźL¬Ý<ĚÝ<,ľoúž$ř=ž˙{Ś #cxz~ťs~AeQfzF‰‚‘±®.´THŞTpŇSđJLÎÎ//ÎÎTHĚKQđŇóŐSđË/ f*häç)$Ąf$ć¤)ä§)„¤F(„»+¸ů‡k꡻ Ć/,Í/I-ÎĚKĎIŐ+)6d```Tg`ěb`bdd řľ†ďÇÂďËľď*úžűŘţ¬¸pÂ÷ă?nŠv.¬śWŇÍŃĆVŇUUŐYÂ!<ˇŰgŠWźwOq{Ú¦nŽĺ˝ëČOeVč=ĐwhžÉ=S»'sđ5Lűá<í»í´ţil'¸.pËq±„äópvópoś=±&ĚďźČĂłnAo˙¤žy=S®™ĘĂËŔü~×endstream endobj 74 0 obj << /Filter /FlateDecode /Length 3756 >> stream xśÍ\[oăĆ~7ň#÷!4vMĎý˛Ň&m“‡Éş- 'h™¶™•DE˘×ë"?·?¤çĚ…ś±uł˝,š]`%‘<·ůćÜć0żNHI'˙„§óŁ_Ź$µĄ1z˘,×%I¸,%›JK®ídUOţ9Y‘ŇjˇťÜđÄŃőŃ÷Ž´.ą•xŁ(µ„)%ÜÇKŁi¤,Jk¸“{ࡀ–Ą“?÷<4¦Tl2Âuv$áżRĐ żÄ§fGďAŕ©ôć’kŕˇÄ}ZÝ€śÔeţ™Î'8?:űɉ-­ŇĚLÎŻŹĽĹčDŠ’qŞ&š‰Ň€nçóŁ‹âw'§”HR\ĐźNN%\±VŚ0rJÄ)áç”˝cü»3ÎĄŇĆľ!ľźütţÝŃ7çNFʬ1Dc–€ŕd–Y˝KDş[DĘJ°<ŠXTërQ-Ú®™×'çżž“ĘÓM”)¬°¶<Łüc1,9U:Ů­E° ˇ­5v§ť·°Ň%%HX]Ç[lú3őg°*_–„Đâďçúűsd©¬ţöâ-Zý1EYr8ôw|éďČR–hn9ÝL„q&XN%“D—–0ůT‹«Md(KQ˝WČčl«,†î“…‹hÄűŰzUWq /şŰ¸PV Ö†X›îľ®űĹŇĹUXZë6 *ׯŁsM—Xo[bĆxIŰň©sźoP15“IôŘĔޒ@Pz‚+{®Ţő»yұ14ma[µ#n}ŕQ„ű€9ŤP[đRú ¸ťĂű‘†‚j x~ţ°‘R9l$¬BŘŕŕńł*>ż6f0pÇZćZŽ3”ŕč‹.@Ŕß˙Eîˇ8--db#€(ˇ<6VDgDśő1úłA&ŐilČ€cç˙˙CLIFń:á±ńŇsÚśŞ†ô”~W#tiDf´±q#-D[y p˘ĆOC¬`Ü!‡k&ťý•‘(ěÉěÄ”†P*2Á`y]lU­ł qÓ|_¶Ým\×}B÷X”¬4ś`-Ę#ÂTÉ4ăéŁĹş«VćżŇĺă!9—.Żýá5Şç/ŠÂWđ+îëŮ,|\Ć µşű6Ňć f;««EĽ EYw[yŠEł¸j¦ˇLđüšëxźŚ «˝[\U«¦vD”ł˘{Ŕöe‰/÷šEWŻpń6/ÖŞDi—ľ>ÁťUřÚ…çĹt†Ëä·2Ĺçł ‰¶¬;Ja{6NŤĺi$ n’˛´ČŃhĽ¨Šţ)3(/3Z\> µÔrUń©YÜD6:R6+Ş.˝•ó}`‚’:Íá řćbz 5Ű,´Ţ\íD@ŻÔ©Ň‡\/,Ss ^śÓŚó¶˘8> ŞÖćąÂľŮ&,?XViKˇUŤöł†2ÎXďÄýęa»™"2n5ă`ęŔ÷xż3XG¨‡˘»ŽBĐlZJ‰•(yFµ|úűŤF&Ąm•ŤÉőŃHĘoŘ’°çLá}Çuý©š/g~[ô!×ílÖŢźPڧđTL‡˘Y(žËö%Ş”`qĄwTÍŰźxT6ĂŤ b¬š±ąk„9¨lŢÁb¬şYÂľÔ¦lŚYŻĚ`SĘ#§° +Ča߸”Ž2řk‰ąëó0űúąż9/N_×%‚şÎm0rŞ+¬€¸bw¤ş‰aIˇm·ćŃí§ăU°Rřjď3c2Ą<2&V€ÉÓ§¦§ŘŹĹ-ľš×+Ţg­ďţW»úŃČ6/‰đ+ńćU0,Ë >:L!”I®wŔ4ł•l•CUl±Ë#¨ľ·ŚÜB"LűÔůębiÓ.ĘŔš…=Śđ=†&ÄCýF-uąZ¬ß°Cďë7üŽiÖoţć}5#X“‹­Šlω P”‚é\ŇÝ;ţ cŠęĹŇn>żëŞËYý˘5ńůŠK^ĽfĂ^Ő‹öÁ,*G‹®Ťź­O=©±.şmďb™ĘłŚĘ(hĚÎŕ\“Ôşë”g4f#ófq×…Ň'ŁČŕ#p}Éu=mc˛™“4ŕ‘čKHâň dź ’AVbŮ®Üö©ˇŻq¬óô›qd”`,aµĄ¶13áFżć›N' *@a;ś·S¦8VżŰ­íO66VÇéȫР=Ł9ńŃŃ!0Sß5<•j72:8D,)ÇBGB}lt$¬ŽźÎ˝ #‚• ŇöL›±1 Ťµ»Ćˇ6N€Ť‹Čł)gca%ˇ>6VVÇ›ěř*´H@‰ÉŐ,°Ş%Ő»ć öĺó´L){ëëŔe˝jÚ«”łXÎĹÓ" ą%4%~{Ů~,´ľPá}Aëżpi€°Ţ"ý–¦;OV^(–K×ôĂ‚P)ÍÖ±ÝLĹP†Ć4ž}Ű ă†Ă‰ MÎę<-*0g7t±U±¬VÝÚ‘d®ký§fµî©*¤Ôw¸áî*6»i1oá”Ć—uP˘©°^ćŹ'lĐđŞÂł!ĂýápÇ’ÜwtwŰLoÝUŻŽűلƺSźcţxÉ]ä{ú GÉ ćJD8¤Ď0¬…m)r –ţüð0Jč¤ńbă•ě„Äv§Ę›O8úö- ‚ĂÎN…=ŕĽcëŚä0ŇąéĽ#Ő“+XTŕééPˇ‹oQV4 Ř.oŁŠ˛x¨«ŐúmĽ®=(âxNx_×ÖÉb-â"RŠH—Hrj„CŚŹ!Uň­—ő´ů˘·Ž ëćf1lęNSoęU<Á”TÍâćm„7/V5őěˇÚ˝|ŃxéďžŐÝŢóGX’Z‘jpČ’>ĽřHoŔÖ/,cĽq:8ź”ňą’Î_6 ›‰ ŕŕ=CTtȵ·ŘýËĎt‡q íR»Ă%Ĺ.ÖĎ5ęĆSâý;:Ué*”lëÄ3M@2†Á]ŽSpŚé™ŕ{üfĆÝŞ’ žsŹŁĆŤ7„µîŁĆă=HÝ?ŠűN'zhBž2ať ţ’ç}ń.–z Ľ Κ‘1ľUíżxźáááö⪚µ‹ÝÖa?¤P‰Ďh_s¬"Ő#qm”v˛}Są(č„ ˇŰ©®ĐëzPÉGr÷ĹňÁ()hŃ.Q&ďĘ5ÄťSöôIşA¬j1+Z8÷.{źľńDźQăöźZ†Lôíî‹+ľśúďЉď“ĺ#JtíěÉý}ő§%xëő@Fddđ Ö˙Ţ+ĐÜgÓű1@9~&َ‡T Ő‰óV©…tŞť.ÖíL±aĚiÁh”ĚRżc6©+Âş˙_4üć×0ă PŐ&şßwßýşÄ]endstream endobj 75 0 obj << /Filter /FlateDecode /Length 4362 >> stream xśÍ\érÉ‘ţϧ@(B1…˘T÷Á]ýiŮëŮ{,RáőŠrhŠ=ÂÁ"5ë}ŠuřýάŞî®¦ŔĂ0Ţ™ĐŐYy|yŐÁŚňĂ˙ÓżăŮ|8řń€‡_éźńlđ‹ÓoüŔR/8Ó‹řƨÖđHXĘťśÎޑӡőÔ[cHq>äŚ2Á™–Ă‘°Ž2¦§Ă‘T’zgÉńbvU,«Őbž“Ĺţkń}R¬čĽ/ęj/#!f=9ěžź«2}s‚ĽIpRĚ'ég/ČE±Ş…˙>ýćŕőéÁď—jp ňţú@0g©ŕËĄˇŽfŠÁ«VµżLNîÔ —C c®§®¨e@’ÁT&*Ą.W5ÁĄćdY^M«qQW‹ů ~s\€ŽH9-®Vĺ$üŔE6…1ź†f–d"´L3&¨Đ9Óé—'3m<§š©Ču±ÂĎŢ+I2S 7`Âüšp¨d ľj|ę ÎëŔ2 ÁX ł}{pú/›‰ľż®ęË÷C‰pц,–H¨2IfhN1çŕť sZŰÍ)©ö¬ťÓ7Ó‘=0'őetČg58—JS-y.9>>ýŻáé÷(AZN»Ą„iuľ,–ź (rF:3 z´÷GË»ăę]3*¦Qďý˙pYŐ­Z\_ăßUÓiąĚ¸'ß9©UTIßSÎ!jf7"§ĆöUąuGŻ11Ü^,łđ'HČ|^Î5€HĂħčk 1_ -Ę$$ő^3T[Á›×ŞUš 7YĚËfz˛^E.ń™†.‡ĺŤĽ…Ëű1© e8™+ëŞ,>” Gv·QK °·ÍçëÁ´Ő{ĎżZóż-@K[/­]°ŐÎpÜĆŔ€†Şť¤˘c„1ç˙8ŚŠ’…Dłd˙u7Ě:Ő Ó=Ň·#Ĺ‹7BfŻ‚|Ęşäe'HHŠ)}‚Q^8X«°ś—Ů„đvooŮä)ˇĄĄč6¶Ď,–Ž]ćU°ťŰá^keďăŢĂ0W3 ¨Ţšä(ßÇĐ_CîC{´XΊů¸|Š B¨čŕ&44ˇM#§k"đ-(hEŻ€BŔp-zŻ@?Ö”¦_Ćś|>‚h/˛—ˇÂ]ĎÇ©´:â*|Ćî†Çî ćäjąřTMĘUóáËňb=MżBbÇöoZ…h~IĺĄĆŠąŞz2E_l&$ŕyµhĆ;RÍ®¦ĺ¬„„1i‰tLA Íi5m2¦á—I‰ąŇ8möf-j†9˘§ĐŢ«Fq$ÚPý…ĄÁ.ŃĄ & íî)[Z]^Fłëďĺ† Fל›6—Dfřöą$›QpKFŹŚ×·Ëób^~|‚—gtµÄ¶<'»mPĘ8ĆĄŚ:ä łÇP¶z&űşÇW ^ŢŚËé*}G×Ń$ř,¶ju(4‚™<´×󲌛…dßĹgŘXe#ăD,:ÇŐşî^`xŞČS ÄI*Ź)% lş ś‘˛­’°FkpT˘#HK“Ő`„+"ŐÂŔ3ňöô|2ť¦{„&+A“˘.c˙(!,Î(Ç58­R><~~˛®BßŃ{ÎËůřrV,?6CT_}ř[ěÇń‹ _ť¤g«z cWÎYĎŁ‡gé1FřŐĺ⺍ţ[dÄę‡â ¨|řWQ—šH»NłŃťŮ)ů¦më˙ő¸ë/ˇ«ĺ)~z2[Ź/ĂŻd<]¬Ęe×zĆęÚË!ËM[műE“Á9›Vř|­b­@]\ŰĹô^%”łŠ™śë‡j+3¤mj”éË|U,3a‚ć S.Š–D.š łĹ˛áť»výâţd`©WĽÇű˝)u¤4§–ë[đOž9çaĺĺ0©4ş*[®49zU„óiąmdnbÔűĘCH°:±E)Ě•ŁVôČ˝ĂŔ҉4)뢚®ňBtĄ‚‚Rů[OÖ3iŃrěç-Š`,ńTRJAS¨eZȂ۔̠Ü/«ó˛ďGą‡·RĄŔzŹŻ+X{§ŕšu}>¤ëË*¸s`€W^”ËUŁtk®ŘŚ—ĺФćˇ5-TqŤ?‡6űóUąędh×§żµĆ‚K°ÝD(ÍŞxOŠÁr\á:c4?f!• Ş€šÝ”TT{Ţ*VˇGú ]Ó!ĆŘ´j†Ń*„ظô`˝¤°ť˛ů÷)=gŹ;(_Tź»Î aEÔçµnŕǤ ć|]M'qy ,÷r>]Ś?®şĺż›âkatüŠćKŃ)Í‚ulŘqčÖŔše@*-’•«:ÍWÉšZsuTô…Ç@62IVµ1ÓbD­+\ý]vČ@KÇ1a?…Rä‹×ĺMťAĺbs U’ÚÔ¦b’/hâÚ—vСľO#ŃV#ńUąÚo7A•r¶NČ«««r>©n¶[ŰL}›´±šŠŰk Űś¬^NÝ×Óz•†€üóć«‹† cü;H »¸…dĎŮ}JfČ)Ä´´}Ú:4dŘN:éI:q"4ni ´šŹ§ëI|ř,hr 1‚cM îpŘP±Ť›čĐçŠćń˝°ŤH>UE7¶Ľ)ÇëfË#δžOBq‘ŘxÓ±Úěźô\ z,ÁB€”rQ^gTt‘yąžĎÓŞaŚĆÍ)]ľ=_ĎëuAt4lËĄ@ź…\pËo«ůú¦y—“ŹĺrVé’#j “ʤďbôbŢQ.ÚĎ2¬ş¶/‚‚íČYĆţŁ őÇß9…Bňm–Ę<ĐFQ E—ŇR\¸bRSČ—`{~°,Ě0 đáá.aÜ U8B0V}Pąh•¤»†rhőmئhúý9N‚ĂpŠŔ"<”°C´đÂßC  ŰTBÄ!_KHÜ"nĄ·LŹqˇÍ5'D$‰9Őł6AÓÔĹĂ="•ÂěZ”ŚęY¶!p߀[îZŚęY»Efň+4/#ŔžsH+ą›÷W‹Uu3}x\ ű·QÄw';®ßBŞĂX§\¨\ńěÂbs+©–rŠý=2h­C*Ć<„ë† ßÇű]SAܱ<źęy†KÄ#&GBš+,âHë#!ź=®Čß<ťŔă ¦7]ľŞ„ٍăěňâÚŢSĎiăÄÓí 9T*B÷íA' šQĚÝę9oŢwÇ?$ ){G4ëZ]˘.ُoÔuS=€:<Ľţă_3vÄŘV( Îô$Ý ˇĄ¸#ÓŢ…ŢQ§űfI‘25¤Ţ;AŽípýóD?˙NqQÜ7»©ŤC|¦C‰új]Ó¸xńŰňúýËŹ[aSAŐ%xąô»Â¦Â5).{´·Ă¦Â0ČyßV śŢ†ť;Á9#<Ł‚ĹŢá©5ŚďžĹ}Ăł› ŕ9 »¸?SĚ$ÝyĚhď&LćfŮo­+@ůĆĆľ[bŘY XtĎŚîž…GĚ”·ŕd 4yÖ­˛?ŰF ~ouNúy™  y躏7ÝÇ˝ąż‡](´ż›đÔJÄdŢ÷Ĺ<ëÚÜikĽó{«G»·"¸žvQźeű<[™Q ęˇŔÍh˙Í\‰ž¤·6´žjGm!s©ľś˙$;r莬·­76©rvĚh˙?°c.i~a{;öä<ËęŤÎj˙†´j„´sú¬wA#˛ ÓcÔ·"őO[eęĺúÓn˛±ďlě÷gcĹqO-çfW6ţ-9Ďú Ogf±3E]łű3Ç“ Ű­ pŤçiűsżě¬ú3ŰÚ@öó.çfG¶K~`®śň-SnYÝÝŃŇ0EY߸Én/÷RŠ5MY>ßłçłŃóÉčůOź˙űŃóżö'Ď_˙´MĐĆP\%íá¦u€HßYv§ĎÖY0ńtcŞ·«q–—ąc°-ş‹Řôń|Ît;h‹Dę(P÷hî­Ć^«ćĚŃt=k•ĺERÖmÇÔ¸ę© î鎷‘WÚ°™q±·>W Ş”čMő ŻnUř¤>='z¸ödäěçßFڶ®Ů»ÂŕAĂľé¶ĺ64‹čű@ ÎܲC¸şU -ń’,żĺ ĂŢęÂîŹIŕj€·i3˙MyîsEđѸ|ě%9€6U1s„4ŞÎPnÖ\# ÁYY9ˇ˙‡żÚ*t­łˇédö¤ĺ?˙ă—¤úÔAP‡Ü0P¬±[…Ë8¦WÎ'Ó%D·)ŕ1´+2ŹUÝŽ4ىCÉăĂ5LđĹčńmęŐ䤚¦ • 4tX¶„ęRŞcĺ÷ÚĹÎ3endstream endobj 76 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 4248 >> stream xśUWw\TÇÚ> śá *›Ł,úíáĆc‰-6Ś ŠŠ  €Ň¤,˝K `ˇHuAAT@±# (EÁ€m±$¤¨1™łwÖű»łKĽćűí?çś™ť÷}ź·<Ď( 5J |e)ńw µq °kíánćę§ü>ź,২ń˙§qŔżgĘŁh¨Ąµ4ŽOŃą«>L@űĆ!‹ń”ş@`ĽÝgM`PTÄË;L¦­µý·łgĎůüeÁňĺËőݢ>­č›x„JĽôg‡żŔ Ź€°Qô‰ˇúúJ7ü\Cô•®HÜ˙ßEQKŤV® r0Ybn±~—k¤›E”űĆčť–žV^ŢÖ›-ľ¶~vţ.ó,\ôý’eßĚžűE}Mm˘¦RVÔ4j3µ‚šNÍ l¨o¨-”-eG͢ě©ŮÔVj5µŤZCÍĄ(ę;Ę‘ZKÍŁL©uÔĘŚ2§Që©ď©Ĺ”µ„ÚH-Ą,)cjĄC ©Ż(–šD‰¨ÉCiQÚÔ8j—Ň  ¨4Á8A„`XÍR-Zí®ÚÔ Ô˝544l5 5.hôŃßŇ;Ŕ°\Ź4'j&k^×üŤ±a™ßĆ,ł˙‹É_ř|©ůĺ¬/źh©i-ŃJÖ*Ňş6vőXʱ÷Ç~жŐţuÜôqĆ;ŽŹ||×řáń˘ mů<(EŽü|©€/Bl)¤ßrkŢŹţôoŤC4*`q @6č9­Í·@)oÓă-ŐáŁe“„5Čś/b±ş˘~ ZQ-ĽŹÔN>čz9ąąĆ{űľäŘ1ś1~GäµŇsRŹÁŃ#»¦eFćAvöbaMN­tdB±C:|ďőČ$á›ÇŃ0ŰĘZn3·ő—‹owčÁÖ łkËᛵM=Ăzđ\âéRIµkž)dp(Ĺťl3ŠĄ‘xVdĺçĚůűşÇ™“ĺCř9{ ˘Qľ˝_ăkĺ‘ŕîĎůą{DŰ@†ÖĎĎéü(C˝2uţ+ľšý.wÝjĽcVK¬Ţo„4FŐöß_j«Dř¶ěşâ]%©Ü‘ż2ń†l_˝ŁUôú mś‡©­ńÉÄąůÇ›÷J›ąš®5÷ągŘ ˙Ű €ś¤.Ďć!{đöîs‘UnLjćB<ÎrZ9÷‡9X ń¸VjQătis[Đ0üľ®íč®­?s˝jů„XÇřG…şn2ňü2SMŃŘWĺż_yĵľě­ ßÂf‡ L)Â)2TĆď—©Ĺö)¸Ş*Ö_ř°úJ۵{UŔ_¤eöPßŮ9>Ř]ě»+!>>¨đ©®@ľه ö‹mUqy®Űćł2«·7˙x§ Łü*WÓŮ\uW ‚CüÝ!<\îĎ*ŠAôršźWw˘–Ň| (˘ëßÂß!Éöü{ďěőá‰č,@|u±w¸ëI#šŃŘëßçTçQeWHLáłŔůădŤĺďŇČüŐn1už/Ör·ŕěWąĚWBެťô!7$@čËs XÓÍ(Žćç«L§<ŹT3/U˝môśÔp¤tżTGŘ‚Ě>×ď-tŞiw·"µ˘Âg´°(-~ojâäÍpGđFFŘBţ®ŚUŠ:>Dż+OĹżŹäT&âF ţ´ůŞÂŇi}ă'Cv˛ŤĂ“„˝|6ŻÍ.JÍ„9ĚłĆY&–;ÝÄ^ޡöĐ Zž xÔ©[ą'o_f")öŁ{ŽÄîŃQ1~1ń!.ń.1ÝYÚ|$535‹[ö‡Ą$ŔfĹGÄ oéG_¶úśYT,6:N {mr¤%zPzěTaÁÉĺY ą]¶3 &Ąěĺ´QEX?§SđËsu^Ť€°T iôRŕ‡§Ń& ÎŚî?(@ňî”D¸[äPĺ]Z‘~(Wśßë—´ź…Çeç§§N= đęô0PvQď(Č^©ó»&"uľśf›Ă0e˛v Ůz—_ÎHÍLËâóšdi±b¦ęôxŃş«nĎnžĽqKś`MÇ TľV*@ďH9Íý–ެ Đů‰¨ťś=ŕ Ţ€žúHţ”`Ę9©ŕň:CţŠЬ›xźđQhg´'dl˝*.f§f§ărďŃsA܆ŃÉŃ0N]Š\«Ë«v7A¤ _÷•ˇIát•ĺŞ2Ę·LDŁF·*ć$ňsčŻެIžćóÄü@öü’cŠ%ô( ú24đRťoşÂîI>@&8!Sz¦§¦síčÚ‘Ra–¨Ëôâ×[b…Ő#ĹOAfŮŃÜÜÜâ⺼zČÜąäy E™¬Q{Ü"W'‰°^‚ën?{;¸™YqÍńĺŮşŁ9Őâ3ŮyYŞ™$Íšne!ŤŮéđČ)qZęňc0…LŮřŤ‹ěAĆÚ÷d]ĺńĘňBîd^yFÓŃźr2RňĎŕľGRš,zŔ+đ–Eh ý@_ŕ,ĽKé_ZŤś^b'UBF§&2$đ”©#%ćĘd=9~™qy±˘’ŕ ± °vW\ĽÜŮÝ€|Ď Ł§3Üw$Dů‹Łăý|nˇ2Ý—XĘö’Qc˝!Ŕ‘s[gŻ5ë\šß-ě*käjﵜ˝ŁšÔpH®Iüú\ĽŞĘÁr–ř“¬ěę8ĹěíülzčRś˛7rŤŮí E»aRjPzĚ*ݽǒŹĂnxĄŞľŹ×kë~ęVÁ#şIš˘˝eSóČ/¦‹`eÔůŕRż3nyÖp4đ°3u˛”`śťňĘĽ«\.F¶Ă!x˙ôĄk%ĺůUů7ĄŔůç5¤_ť›Ú‹U’y»ąĽ2mµŢÖűHîá´ĺ}ٵÎ{MD/řwUĽ#­„ć)YxŔż}Ô\!פ1;)YaůwýdŹ2a=üřŤDŞb×Đč2Pp í(cš7y=4~ ř)üXúź‰"ô&č–‚M¸Ę·Ă˝ÄаŹb/<¦ÓčŹúKą'Ďsĺ…9yąe1Fşëónl_ö%V1–ţöÜN3‰%dŚ]šźß(h/˝Âť»ßx¦]EnŁ‘ČëČń *~ĆéüĎôÔ˙ą®ĂËPšBF˙9Z:ȬÍď<ĺÜ;(žM/Čl<\KE#ËbęűĄnfŰÄNž@h{bK­çYICĚM´ŕűľ D„˝LíĽĚ óĂŽ¦gE©Y‡ň¸Â¶äu_ű dş/:®Úť’”Ă© oމ¦¸k1Č»źÝ\XPEGᛜw_7ęPbj 4„6;bŚ#ę®UŔ`–b;á…_říôs0*ę†P&aŻ #ęčşË˘HĐ/ç_¬nk®~™?-®cm1ľţij=á'ł×Q&ŤěŔ@ťÄÂ;Á'Ěźóqu‰Ü *fĐŘ~vż Ź`PL|‹^[ą;7<_|Ü7[BZéá°ŃÎÜÓpÝFďÚn—¶4‹Dŕ)¶¶˙‚˘u#šK5SâSöÂ}đ€ČđÁ¶żwź¬ż(nn,m-EÂ7ü]Ľg#Ű^ç¸jc”q çciĺ± 2f®ÍŹď´źľĘUwܨií0ĄŔSuuÔ°: ˙ÔŐ*}w©=čzEWŞ$[ ÜÄ­Ć#˙PwÇDŹ·^^şĘ!ÂĘB|ťPń˝]Vę;ţö[Ó‘"ď†ŃQÔɢ˝@ř¦Ł:Ř!ú`ÄţpNř6ô}ő`ljbzhpřDü±˝Ça±K+8TDČ0§+ăjˇl/rި-ÎĎ.Ěg„ĂçkJ;ďęýąą%ĆĂź€ĘëŹ*ľhĐK’ŽGäÄe„ÁPčëŕĺ­L !±ľ/@ąůĄŕo ě>ň>Ť<“¤«4›Îđë#čęÓkÂŕr;ţ{¤,-ćÁúK>§ÝŞíňWÂiĐ ŔÖĆÍŐĎn… vť‘ČČQWřćǰĘG=čéěćią‚ÚľîUNjfúqî{ś#¬őr šýAvúúmń•ËŐ˝đ,ŮS{2ül€Ô)ŻjŇö‡JôŕŮĽŠÓĄ5•Mů÷ȦşÄâ]ÇŁs|aÜ“’tp—JŹIĺšC~·ś§=*Mň@©ĘĐ>€Ĺ'bSÉ6«‚ý;ĂőČů/¸ĐÖG#(™Ó¸Đ*ýŞ$X4žčW»Q†ÍŚą|)NŃěő—îç¦ĺ¦çsHŔgvť®IňIr„±"čvbŰ™€ ž÷"ú!ú"ö§ 4CąKW••wţ醪ŐTcqĘD~™…3V|\Ć$´ô٢š›Ł×ůaŐ5dýg÷ ‘kČŁü®»ť“›*ÝSâĆs†řăčZţŔý;=Ptůt€c,„{$ÜüYyĚŹIĎNŻ„Ů"X’P¶ëDřÉ ¬íp=´¶˛Žą±łÔ®ŰwmŘÄŚ^ZPL '“f‹ßÓN űŽ´äܡŚZÝŤśť˘ "ľŃ»űżĘP?éî%ňmě2hęnłÜbž6x:´,´;ăWáßŐźĂ{çn=mÝĚ šĘ mł^L‹ ŮŽZ'ą>xŽÇ Î}±“aE ŹĆÇ?źAłÎ=ájź4ž˙Ô´^ťOc1ĄHŁeÍ–oŁ7[LEÄăi»â-”îŔ|ą ś&ν`cAAÓő¦W‘ĆM]$ęěx‡ ±uAĺ’sŽ…ë ţ.2܉W22pěâ±ňÂS ͧnAćÁ%— 7-sĺ¦ÚcăyŰmťńbď >Ĺ«Ó-C­2g’•7¨ °EiY0’kÜ“&‰5¦Vc §ÚÖŚÔĽ´|.-‡^ř§ÄÁ(˘Sş¬Đ„—ŹĘo\_j*ëđfxĄMiügŤ5·‡ődknaµeký·8$Q‘kkY ™'ó¤ĺOÜ€LÇ[ŹxĎ0.ČĎ.f5dö Í ˙ CÖ xŞ‘!ˇˇ‚ú_ŕWŢ•6Šď6»ćŃč>ąęT‹ZGiµ÷#ë~ť72Ô,s!!}ŕ˙"…FA<ÂŚŢŐź»bŰL ńćůNx-ąµ1yhŚľxÖ[Ós],ä/´”t·ę˝7éŇ7· ˛¶źF+‡>Ľ…' tAâ‰ŘŚ„#ţŚđĂáSô` LNIf/b…|×%çőXcĹ‚™¦MÝ>{ÇŤşSهÂúuúdGeČW…ńżQ?†ýÚŃv%śÎL4G:O»Ď´Ý őŤ§îŢÔ·‚lÎd>śžžváTVFľ”ţ»´Ş ±žŚ‘¸łˇ%>g 6ž± Ýjçę¶nÎY‘uY˘4¶‹ /ŮĘJvĆŘÂpݏ:ÔvűgݰBĹ@ł«ů¬«ľ6ŢZßöË`˙[ŮľGݤ5ßłS•Cô€4f?+çYő•oeɇF°Ű:"Đk˙^ÝÖC ŤŹ‹~'•:(EV„¬e¨Ĺî ąĐk3vˇÉ‹R踓—ť„žĐNĺ ąĐˇ¤úu°xŻjÇ^ rD€$˙óB;ě_$EĄ'ŔŔ˛/kiQÔÓXIendstream endobj 77 0 obj << /Filter /FlateDecode /Length 2338 >> stream xśµYŰŽŰFöqľBŔľ4‘Ő÷K€<řšÍÄqÖŮ~°Ąˇ%ÚI);ö/˛Ř/ÜŮŞľđ2–×Af†1C˛/ŐU§NťęůeBs6ˇř/ţ\]źŃÉúě—3ćßNâŹŐőäţâl6gbbr*©c“ĹŰ3–SŞĂ°‰bąNM —ą…ź‹ëłWäŃŐUY/3Nɱl۲ΦÜŔ|FfÚĺÎ8GÎÓ;IgRÁ/L‘C_ťŇšŰŐ®jŇFć~ĽÎ)Wä^]ŐˇŚ©$™ đEŽV}ŢlJ°gXň ß+X[’ăJÎ’3 ß™adwŚą$ĎÂ2?6MY×Ýč§Ýâ–Ü/Ú˛‰kDz0ÄŇ™ÉČMq˝,éđ梷â5á”Ó×YžýcqVnč`îŕApđâ Ü9_í÷ßfS!,C.Ëâ:ٰŠfĚ‘şlšh˘3dŢ›XlŻâvV’ß|Ó»ë‡m[®3G§`ÉŔçmµŰF{nśóÜh•ěÉÁ«ýÉç}XöĹ*c]ŁČűb=χŚC€)wÜ{tF’ruî÷dPEÍÄ0™;nOäůüI¶xwöhqöěŚć€68»}řĂŤ‹Ă¶Fj6\ýŮ´íľův6{0ż÷4źOł©A€„ö‡Ý»rŐć»ĂÚü®;"×ţßadĽőÁ¶?žAŃ.ů|tÚĎ:eVäÜɶÓFŮŕů.±ŔăZڞËYL/QŐ‡Ö'ÂeU‡0RŮ´‡lĘŕ‰sKŞ8Ő8ň$N"6™ű6…Č'$l‹í®­®ËN y ŻšrµŰ^Mçeł«ŹmŚ8ZcČF§'ňÖ'.5’ěń%ELťÄ ˘ßŃt0ΊňÎĘč1ńB ‚‹­V# Ńśçrŕ.[Ń[ˇMRÁ“CakđâІ.{‡h çK>ľ Δ4ąvCC"̤‚Pe:,ÂEH ‘&yF‘űhŇŔS/}퇀Iôy„Hâ{Ęi;?[݇I„ID®Čď~Ş)ÂZr´˘‡çĺŁGl˙ú!Pr ŞJě‡"`3 X=âC€pňŻ´ą»ËsĹÁÓr˙qď>ćňŹ?f ŮÂśůR(ŔŘU öÁ»ŐîzÖ–«ÍÖó»bš‘˛ý詚…ń§Ö~?+ŕIŕbPÚ Vhfď ĎNNۡçfďŢ2p†‰p~ŠO(‘)ŹC8„Đ&ß´×őm'Ë­µC7$Ä8´7íűĂ®.ŻŃ#0Ë’c>Iľ#/«ŔľV÷P[˛ůŰ d±1˛¦bč3h4üT\•ýŔGEó©ŁŞŹU»éęă2±¨T¤B—F\QÄŐÉ’BIIťčëb‡yâÓ Şč¶¨{úŰ˝íY벅˘Ü@x»`×ĺî-‚"î^Ę“|éxn‹| i ľźÍG&_C d!i2^Ĺä–;Ýńýk"^g1ěß`~ĎÂwÉ›JC™đX<Ł:ťC’äďpOŢđśůAŇYEĹěV<©dÎ pť#l…2ÁÜ).7ułÚÔ˙Y—]|xyLó™gDÎt Ŕ+˛¬Z-}%•XČ˝ľ:_Оę˘ŔůT uäEf]€\ ¤ě=ćčҶě˝.DÁzşüňś‰wX~ÝÔäěĽ?ĐI€‡!¤ŕ™ś"Őü©ěăr+TQ•+«†fTQĎŤăFJk„óŃÖË}µb!Çŕ”ň/2Ć5ŠĽPŠ1Ę6Ń'óş%ú´€HźÎ÷6HˇľĚUFµľuJŠĄé– ťkŢY¤B . =„5  Ô÷ ËtN–E]m×qwčbzvőźa»@ŘńśPžTm[—˝©@ŃUy8 X% !#ŔşˇÁů`uXç-Ź€QÝ6Ě8ĺî<Ů®ďŻCH(ęZN¶(Đ"śŔl .÷T_Ą•ĘŹşdPǰŔŕÝçPp-–öÁÎ-ż‰shú™ŇÁĹ]o™obŢ—ŰřÔĐ>îń‘{śúŻCwÂ÷ ż÷ł­ζ7'ß/š4¤ŕĺľ\UYů¶·I4ůˇiŽť5ŚóđÉ#ÇŹ-ĽZCpHźĐ©Qj 4=±ŐÁ…€żˇ”čd Tmß5é…€ľl»*ÓhbáÂ÷ŇŹö¨­…:Dv«M¸Ęiqá©X°„őE† ;®Z2Š`ërŹuB˘Ţßö_.Ű«äN`?(NS–ťÎ.Š%ZłË‰»ÖŇ ˛Đ$3ëF2`\6^QB`17Ěqâc.¤'Fź»-°M‰Sf e ¨x5űu ŔŰŮ ůć×ĺŐ›Ő¦ŘC“„ň÷Żm±~ĂŮЎ0Ć~äč-DH—v(Ş Ľđq’EQěLđęóòؖď{ˇ{™~¤Á)Ä ďS)|Ş˛©Ň–ń\t7Ł=ľ¨Ö[\ †3U–ü3ĆĚ M“FćÜtävŃ]8ëĐó’n%#ś%Ë"W= †kĘܤ…aŰx0as\w%®»nvö_NH µendstream endobj 78 0 obj << /Type /XRef /Length 116 /Filter /FlateDecode /DecodeParms << /Columns 5 /Predictor 12 >> /W [ 1 3 1 ] /Info 3 0 R /Root 2 0 R /Size 79 /ID [<159194c3601730392e11b7504fd1663e>] >> stream xścb&F~0ů‰ $Ŕ8J’LţgŕŃ9dł>…ˇřjÉÁ "…¦€H‰Ó R¸Dň˙‘\gA$çu°ě7°ú,°Ţ.ÉS"™r@$_8$ŞAlŢ-`Ů`ŮŻ`[‚A¤ 89łů•‘ endstream endobj startxref 84901 %%EOF nanotime/inst/doc/nanotime-introduction.Rnw0000644000176200001440000000052013705546565020644 0ustar liggesusers\documentclass{article} \usepackage{pdfpages} %\VignetteIndexEntry{Introduction to nanotime} %\VignetteKeywords{nanotime, nanoperiod, nanoival, nanoduration, date, datetime, time, nanoseconds} %\VignettePackage{nanotime} %\VignetteEncoding{UTF-8} \begin{document} \includepdf[pages=-, fitpaper=true]{nanotime-intro.pdf} \end{document} nanotime/inst/include/0000755000176200001440000000000013703333711014465 5ustar liggesusersnanotime/inst/include/nanotime/0000755000176200001440000000000014146544040016300 5ustar liggesusersnanotime/inst/include/nanotime/duration.hpp0000644000176200001440000000037013703333711020635 0ustar liggesusers#ifndef NANOTIME_DURATION_HPP #define NANOTIME_DURATION_HPP #include #include "globals.hpp" namespace nanotime { duration from_string(const std::string& str); std::string to_string(duration d); bool is_na(duration d); } #endif nanotime/inst/include/nanotime/period.hpp0000644000176200001440000001257314146544040020303 0ustar liggesusers#ifndef NANOTIME_PERIOD_HPP #define NANOTIME_PERIOD_HPP #include "globals.hpp" #include "interval.hpp" #include namespace nanotime { inline duration getOffsetCnv(const dtime& dt, const std::string& z) { int offset; int res = RcppCCTZ::getOffset(std::chrono::duration_cast(dt.time_since_epoch()).count(), z.c_str(), offset); if (res < 0) { Rcpp::stop("Cannot retrieve timezone '%s'.", z.c_str()); // ## nocov } return duration(offset).count() * std::chrono::seconds(1); } struct period { typedef int32_t month_t ; typedef int32_t day_t; period() : months(0), days(0), dur(std::chrono::seconds(0)) { } period(int32_t months_p, int32_t days_p, duration dur_p) : months(months_p), days(days_p), dur(dur_p) { // we have to ensure that NA is uniform across all construction // possibilities so that functions that compare equality do so // correctly: if (months == std::numeric_limits::min() || days == std::numeric_limits::min() || dur == duration::min()) { months = std::numeric_limits::min(); days = std::numeric_limits::min(); dur = duration::zero(); } } period(const std::string& s); inline month_t getMonths() const { return months; } inline day_t getDays() const { return days; } inline duration getDuration() const { return dur; } inline void setMonths(int64_t m) { months = m; } inline void setDays(int64_t d) { days = d; } inline void setDuration(duration d) { dur = d; } inline void addMonths(int64_t m) { months += m; } inline void addDays(int64_t d) { days += d; } inline void addDuration(duration d) { dur += d; } inline bool operator==(const period& p) { return months==p.months && days==p.days && dur==p.dur; } inline bool operator!=(const period& p) { return months!=p.months || days!=p.days || dur!=p.dur; } inline bool isNA() const { return months == std::numeric_limits::min() || dur == duration::min(); } private: month_t months; day_t days; duration dur; }; inline period operator-(const period& p) { return period(-p.getMonths(), -p.getDays(), -p.getDuration()); } inline period operator+(const period& p1, const period& p2) { return period(p1.getMonths()+p2.getMonths(), p1.getDays()+p2.getDays(), p1.getDuration()+p2.getDuration()); } inline period operator-(const period& p1, const period& p2) { return period(p1.getMonths()-p2.getMonths(), p1.getDays()-p2.getDays(), p1.getDuration()-p2.getDuration()); } inline period plus (const period& p, duration d) { return period(p.getMonths(), p.getDays(), p.getDuration() + d); } inline period plus (duration d, const period& p) { return plus(p, d); } inline period minus(const period& p, duration d) { return period(p.getMonths(), p.getDays(), p.getDuration() - d); } inline period minus(duration d, const period& p) { return period(-p.getMonths(), -p.getDays(), -p.getDuration() + d); } inline dtime plus(const dtime& dt, const period& p, const std::string& z) { auto res = dt; auto offset = getOffsetCnv(res, z); if (p.getMonths()) { auto dt_floor = date::floor(dt + offset); auto timeofday_offset = (dt + offset) - dt_floor; auto dt_ymd = date::year_month_day{dt_floor}; dt_ymd += date::months(p.getMonths()); res = date::sys_days(dt_ymd) - offset + timeofday_offset; } offset = getOffsetCnv(dt, z); res += p.getDays()*std::chrono::hours(24); res += p.getDuration(); auto new_offset = getOffsetCnv(res, z); // adjust for DST or any other event that changed the TZ, but only // if the adjustment does not put us back in the old offset: if (new_offset != offset) { auto res_potential = res + offset - new_offset; // adjust auto adjusted_offset = getOffsetCnv(res_potential, z); if (adjusted_offset == new_offset) { // are we still in the new offset? res = res_potential; // if so, then keep the adjustment } } return res; } inline dtime plus (const period& p, const dtime& dt, const std::string& z) { return plus(dt, p, z); } inline dtime minus(const dtime& dt, const period& p, const std::string& z) { return plus(dt, -p, z); } inline interval plus (const interval& i, const period& p, const std::string& z) { return interval(plus(dtime{duration{i.s}}, p, z), plus(dtime{duration{i.e}}, p, z), i.sopen, i.eopen); } inline interval plus (const period& p, const interval& i, const std::string& z) { return plus(i, p, z); } inline interval minus(const interval& i, const period& p, const std::string& z) { return plus(i, -p, z); } template period operator*(const period& p, T d); template period operator/(const period& p, T d); bool operator==(const period& p1, const period& p2); bool operator!=(const period& p1, const period& p2); /// This operator is meaningless, but needs to be defined because of /// the intended template usage. //inline bool operator<(const period& p1, const period& p2) { return false; } std::string to_string(const period& p); } // end namespace nanotime #endif nanotime/inst/include/nanotime/pseudovector.hpp0000644000176200001440000000320013703333711021525 0ustar liggesusers#ifndef NANOTIME_PSEUDOVECTOR_HPP #define NANOTIME_PSEUDOVECTOR_HPP #include namespace nanotime { // a thin wrapper that gives us the vector recycling behaviour of R: template struct PseudoVector { PseudoVector(Rcpp::Vector& v_p) : v(v_p), sz(v_p.size()) { } inline R& operator[](R_xlen_t i) { return i(&v[i]) : *reinterpret_cast(v[i%sz]); } inline R_xlen_t size() const { return sz; } inline bool isScalar() const { return v.size()==1; } private: Rcpp::Vector& v; const R_xlen_t sz; }; template struct ConstPseudoVector { ConstPseudoVector(const Rcpp::Vector& v_p) : v(v_p), sz(v_p.size()) { } inline const R& operator[](R_xlen_t i) const { return i(&v[i]) : *reinterpret_cast(&v[i%sz]); } inline R_xlen_t size() const { return sz; } inline bool isScalar() const { return v.size()==1; } private: const Rcpp::Vector& v; const R_xlen_t sz; }; // character is a special case that needs a bit of help: template <> struct ConstPseudoVector { ConstPseudoVector(const Rcpp::Vector& v_p) : v(v_p), sz(v_p.size()) { } inline const Rcpp::CharacterVector::const_Proxy operator[](R_xlen_t i) const { return i& v; const R_xlen_t sz; }; } // end namespace nanotime #endif nanotime/inst/include/nanotime/interval.hpp0000644000176200001440000002711213723716541020647 0ustar liggesusers#ifndef NANOTIME_INTERVAL_HPP #define NANOTIME_INTERVAL_HPP #include #include #include #include "globals.hpp" namespace nanotime { struct interval { #ifdef WORDS_BIGENDIAN constexpr interval() : s(0), sopen(0), e(0), eopen(0) { } #else constexpr interval() : sopen(0), s(0), eopen(0), e(0) { } #endif interval(dtime s_p, dtime e_p, int sopen_p, int eopen_p) #ifdef WORDS_BIGENDIAN : s(s_p.time_since_epoch().count()), sopen(sopen_p), e(e_p.time_since_epoch().count()), eopen(eopen_p) { #else : sopen(sopen_p), s(s_p.time_since_epoch().count()), eopen(eopen_p), e(e_p.time_since_epoch().count()) { #endif // if any of the constructor parameters is NA, we construct an NA interval: if (s_p.time_since_epoch() == duration::min() || e_p.time_since_epoch() == duration::min() || sopen_p == NA_INTEGER || eopen_p == NA_INTEGER) { s = IVAL_NA; e = IVAL_NA; } else { if (s_p.time_since_epoch().count() < IVAL_MIN || e_p.time_since_epoch().count() < IVAL_MIN) { s = IVAL_NA; e = IVAL_NA; Rf_warning("NAs produced by time overflow (remember that interval times are coded with 63 bits)"); } if (s_p.time_since_epoch().count() > IVAL_MAX || e_p.time_since_epoch().count() > IVAL_MAX) { s = IVAL_NA; e = IVAL_NA; Rf_warning("NAs produced by time overflow (remember that interval times are coded with 63 bits)"); } if (s > e) { std::stringstream ss; ss << "interval end (" << e << ") smaller than interval start (" << s << ")"; throw std::range_error(ss.str()); } } } // interval(std::int64_t s_p, std::int64_t e_p, bool sopen_p, bool eopen_p) // : sopen(sopen_p), s(s_p), eopen(eopen_p), e(e_p) { // if (s > e) { // std::stringstream ss; // ss << "interval end (" << e << ") smaller than interval start (" << s << ")"; // throw std::range_error(ss.str()); // } // } dtime getStart() const { return dtime(duration(s)); } dtime getEnd() const { return dtime(duration(e)); } bool isNA() const { return s == IVAL_NA; } #ifdef WORDS_BIGENDIAN std::int64_t s : 63; bool sopen : 1; // encode if the interval's start boundary is open (true) or closed (false) std::int64_t e : 63; bool eopen : 1; // encode if the interval's end boundary is open (true) or closed (false) #else bool sopen : 1; // encode if the interval's start boundary is open (true) or closed (false) std::int64_t s : 63; bool eopen : 1; // encode if the interval's end boundary is open (true) or closed (false) std::int64_t e : 63; #endif static const std::int64_t IVAL_MAX = 4611686018427387903LL; static const std::int64_t IVAL_MIN = -4611686018427387903LL; static const std::int64_t IVAL_NA = -4611686018427387904LL; }; // operators: inline duration operator-(const interval& i1, const interval& i2) { return duration(i1.s - i2.s); } inline bool operator==(const interval& i1, const interval& i2) { return i1.s == i2.s && i1.e == i2.e && i1.sopen == i2.sopen && i1.eopen == i2.eopen; } inline bool operator!=(const interval& i1, const interval& i2) { return !(i1 == i2); } inline bool operator<=(const interval& i1, const interval& i2) { if (i1.s < i2.s) return true; if (i1.s == i2.s) { if (!i1.sopen && i2.sopen) return true; if (i1.sopen && !i2.sopen) return false; // here we know that s1.sopen == s2.sopen if (i1.e < i2.e) return true; if (i1.e == i2.e) { if (i1.eopen == i2.eopen) return true; if (i1.eopen && !i2.eopen) return true; } } return false; } inline bool operator<(const interval& i1, const interval& i2) { if (i1.s < i2.s) return true; if (i1.s == i2.s) { if (!i1.sopen && i2.sopen) return true; if (i1.sopen && !i2.sopen) return false; // here we know that s1.sopen == s2.sopen if (i1.e < i2.e) return true; if (i1.e == i2.e) { if (i1.eopen == i2.eopen) return false; if (i1.eopen && !i2.eopen) return true; } } return false; } inline bool operator>(const interval& i1, const interval& i2) { return !(i1 <= i2); } inline bool operator>=(const interval& i1, const interval& i2) { return !(i1 < i2); } inline bool operator<(const dtime& i1, const interval& i2) { if (i1.time_since_epoch().count() < i2.s) return true; if (i1.time_since_epoch().count() == i2.s) return i2.sopen; return false; } inline bool operator>(const dtime& i1, const interval& i2) { if (i1.time_since_epoch().count() > i2.e) return true; if (i1.time_since_epoch().count() == i2.e) return i2.eopen; return false; } inline interval operator+(const interval& i, const duration d) { // test duration is not > 63-bits, and after that the constructor can test for overflow: return interval(i.getStart() + d, i.getEnd() + d, i.sopen, i.eopen); } inline interval operator-(const interval& i, const duration d) { // test duration is not > 63-bits, and after that the constructor can test for underflow: return interval(i.getStart() - d, i.getEnd() - d, i.sopen, i.eopen); } inline interval operator+(const duration d, const interval& i) { // test duration is not > 63-bits, and after that the constructor can test for overflow: return interval(i.getStart() + d, i.getEnd() + d, i.sopen, i.eopen); } // interval components comparators: inline bool start_lt(dtime s1, bool sopen1, dtime s2, bool sopen2) { if (s1 < s2) return true; if (s1 > s2) return false; return !sopen1 && sopen2; } inline bool start_gt(dtime s1, bool sopen1, dtime s2, bool sopen2) { if (s1 > s2) return true; if (s1 < s2) return false; return sopen1 && !sopen2; } inline bool start_le(dtime s1, bool sopen1, dtime s2, bool sopen2) { return !start_gt(s1, sopen1, s2, sopen2); } inline bool start_ge(dtime s1, bool sopen1, dtime s2, bool sopen2) { return !start_lt(s1, sopen1, s2, sopen2); } inline bool end_lt(dtime e1, bool eopen1, dtime e2, bool eopen2) { if (e1 < e2) return true; if (e1 > e2) return false; return eopen1 && !eopen2; } inline bool end_gt(dtime e1, bool eopen1, dtime e2, bool eopen2) { if (e1 > e2) return true; if (e1 < e2) return false; return !eopen1 && eopen2; } inline bool end_le(dtime e1, bool eopen1, dtime e2, bool eopen2) { return !end_gt(e1, eopen1, e2, eopen2); } inline bool end_ge(dtime e1, bool eopen1, dtime e2, bool eopen2) { return !end_lt(e1, eopen1, e2, eopen2); } // interval comparators: inline bool start_lt(const interval& i1, const interval& i2) { return start_lt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen); } inline bool start_gt(const interval& i1, const interval& i2) { return start_gt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen); } inline bool start_le(const interval& i1, const interval& i2) { return !start_gt(i1,i2); } inline bool start_ge(const interval& i1, const interval& i2) { return !start_lt(i1,i2); } inline bool end_lt(const interval& i1, const interval& i2) { return end_lt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen); } inline bool end_gt(const interval& i1, const interval& i2) { return end_gt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen); } inline bool end_le(const interval& i1, const interval& i2) { return !end_gt(i1,i2); } inline bool end_ge(const interval& i1, const interval& i2) { return !end_lt(i1,i2); } /// True if the end of 'i1' is smaller than the start of 'i2'. This /// tests that 'i1' and 'i2' are disjoint and 'i2' is after 'i1'. inline bool end_lt_start(const interval& i1, const interval& i2) { return end_lt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen); } inline bool end_gt_start(const interval& i1, const interval& i2) { return end_gt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen); } /// True if the end of 'i1' is greater or equal than the start of /// 'i2'. This tests that 'i1' and 'i2' "touch" and that 'i2' is /// after 'i1'. inline bool end_ge_start(const interval& i1, const interval& i2) { return !end_lt_start(i1, i2); } inline bool end_le_start(const interval& i1, const interval& i2) { return !end_gt_start(i1, i2); } // Unions -------------------------------------------------------- /// In unions, we have the following rules: oo is disjoint, but oc, /// co, and cc touch // interval components comparators: inline bool union_start_lt(dtime s1, bool sopen1, dtime s2, bool sopen2) { if (s1 < s2) return true; if (s1 > s2) return false; return sopen1 || sopen2; } inline bool union_start_gt(dtime s1, bool sopen1, dtime s2, bool sopen2) { if (s1 > s2) return true; if (s1 < s2) return false; return sopen1 || sopen2; } inline bool union_start_le(dtime s1, bool sopen1, dtime s2, bool sopen2) { return !union_start_gt(s1, sopen1, s2, sopen2); } inline bool union_start_ge(dtime s1, bool sopen1, dtime s2, bool sopen2) { return !union_start_lt(s1, sopen1, s2, sopen2); } inline bool union_end_lt(dtime e1, bool eopen1, dtime e2, bool eopen2) { if (e1 < e2) return true; if (e1 > e2) return false; return eopen1 && eopen2; } inline bool union_end_gt(dtime e1, bool eopen1, dtime e2, bool eopen2) { if (e1 > e2) return true; if (e1 < e2) return false; return eopen1 && eopen2; } inline bool union_end_le(dtime e1, bool eopen1, dtime e2, bool eopen2) { return !union_end_gt(e1, eopen1, e2, eopen2); } inline bool union_end_ge(dtime e1, bool eopen1, dtime e2, bool eopen2) { return !union_end_lt(e1, eopen1, e2, eopen2); } // interval comparators: inline bool union_start_lt(const interval& i1, const interval& i2) { return union_start_lt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen); } inline bool union_start_gt(const interval& i1, const interval& i2) { return union_start_gt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen); } inline bool union_start_le(const interval& i1, const interval& i2) { return !union_start_gt(i1,i2); } inline bool union_start_ge(const interval& i1, const interval& i2) { return !union_start_lt(i1,i2); } inline bool union_end_lt(const interval& i1, const interval& i2) { return union_end_lt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen); } inline bool union_end_gt(const interval& i1, const interval& i2) { return union_end_gt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen); } inline bool union_end_le(const interval& i1, const interval& i2) { return !union_end_gt(i1,i2); } inline bool union_end_ge(const interval& i1, const interval& i2) { return !union_end_lt(i1,i2); } /// True if the end of 'i1' is smaller than the start of 'i2'. This /// tests that 'i1' and 'i2' are disjoint and 'i2' is after 'i1'. inline bool union_end_lt_start(const interval& i1, const interval& i2) { return union_end_lt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen); } inline bool union_end_gt_start(const interval& i1, const interval& i2) { return union_end_gt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen); } /// True if the end of 'i1' is greater or equal than the start of /// 'i2'. This tests that 'i1' and 'i2' "touch" and that 'i2' is /// after 'i1'. inline bool union_end_ge_start(const interval& i1, const interval& i2) { return !union_end_lt_start(i1, i2); } inline bool union_end_le_start(const interval& i1, const interval& i2) { return !union_end_gt_start(i1, i2); } } // end namespace nanotime #endif nanotime/inst/include/nanotime/utilities.hpp0000644000176200001440000000743113713656775021053 0ustar liggesusers#ifndef NANOTIME_UTILITIES_HPP #define NANOTIME_UTILITIES_HPP namespace nanotime { // helper functions to manage name copying in binary operations: inline Rcpp::CharacterVector copyNamesOut(const Rcpp::CharacterVector& nm) { if (nm.size() == 0) return nm; else { Rcpp::CharacterVector res = clone(nm); return res; } } inline Rcpp::CharacterVector getNames(const Rcpp::CharacterVector& nm1, bool scalar1, const Rcpp::CharacterVector& nm2, bool scalar2) { // these are the R rules for name handling in binary operations: if (nm1.size() == 0) return copyNamesOut(nm2); else if (nm2.size() == 0) return copyNamesOut(nm1); else if (scalar1 && !scalar2) return copyNamesOut(nm2); else if (scalar2 && !scalar1) return copyNamesOut(nm1); else return copyNamesOut(nm1); } template void copyNames(const Rcpp::Vector& e1_cv, const Rcpp::Vector& e2_cv, Rcpp::Vector& res) { auto nm1 = e1_cv.hasAttribute("names") ? Rcpp::CharacterVector(e1_cv.names()) : Rcpp::CharacterVector(0); auto nm2 = e2_cv.hasAttribute("names") ? Rcpp::CharacterVector(e2_cv.names()) : Rcpp::CharacterVector(0); auto resnames = getNames(nm1, e1_cv.size() == 1, nm2, e2_cv.size() == 1); if (resnames.size()) { res.names() = resnames; } } // helper functions to set the class and the S4 bit on R objects: template SEXP assignS4(const char* classname, Rcpp::Vector& res) { Rcpp::CharacterVector cl = Rcpp::CharacterVector::create(classname); cl.attr("package") = "nanotime"; res.attr("class") = cl; SET_S4_OBJECT(res); return Rcpp::S4(res); } // .S3Class is needed for S4 classes that are based on S3 classes: template SEXP assignS4(const char* classname, Rcpp::Vector& res, const char* oldClass) { Rcpp::CharacterVector cl = Rcpp::CharacterVector::create(classname); cl.attr("package") = "nanotime"; res.attr("class") = cl; // use 'install' here as in R source code attrib.c: LLL Rcpp::CharacterVector oc = Rcpp::CharacterVector::create(oldClass); res.attr(".S3Class") = oc; SET_S4_OBJECT(res); return Rcpp::S4(res); } inline void checkVectorsLengths(SEXP x, SEXP y) { auto nx = XLENGTH(x); auto ny = XLENGTH(y); // the following as in R source code: 'arithmetic.c' function 'R_binary': if (nx > 0 && ny > 0 && ((nx > ny) ? nx % ny : ny % nx) != 0) { Rf_warning("longer object length is not a multiple of shorter object length"); } } inline void checkVectorsLengths(SEXP x, SEXP y, SEXP z) { checkVectorsLengths(x, y); checkVectorsLengths(x, z); checkVectorsLengths(y, z); } inline void checkVectorsLengths(SEXP x, SEXP y, SEXP z, SEXP u) { checkVectorsLengths(x, y, z); checkVectorsLengths(x, y, u); checkVectorsLengths(y, z, u); } inline ssize_t getVectorLengths(SEXP x, SEXP y) { if (XLENGTH(x) == 0 || XLENGTH(y) == 0) { return 0; } else { return std::max(XLENGTH(x), XLENGTH(y)); } } inline ssize_t getVectorLengths(SEXP x, SEXP y, SEXP z) { if (XLENGTH(x) == 0 || XLENGTH(y) == 0 || XLENGTH(z) == 0) { return 0; } else { return std::max(XLENGTH(x), std::max(XLENGTH(y), XLENGTH(z))); } } inline ssize_t getVectorLengths(SEXP x, SEXP y, SEXP z, SEXP u) { if (XLENGTH(x) == 0 || XLENGTH(y) == 0 || XLENGTH(z) == 0 || XLENGTH(u)==0) { return 0; } else { return std::max(std::max(XLENGTH(x), XLENGTH(y)), std::max(XLENGTH(z), XLENGTH(u))); } } // SunOS has no strnlen_; definition in src/strnlen.cpp size_t strnlen_(const char *s, size_t maxlen); } // end namespace nanotime #endif nanotime/inst/include/nanotime/globals.hpp0000644000176200001440000002253413713656775020464 0ustar liggesusers#ifndef NANOTIME_GLOBALS_HPP #define NANOTIME_GLOBALS_HPP #include #include #include "date.h" #include "cctz/civil_time.h" #include "cctz/time_zone.h" namespace nanotime { using duration = std::chrono::nanoseconds; using dtime = std::chrono::time_point; inline bool readNumber(const char*& s, const char* e, int& n, bool dosign) { n = 1; auto sorig = s; int sign = 1; if (dosign && *s == '-') { sign = -1; ++s; } if (s == e || !isdigit(*s)) { s = sorig; return false; } else { n *= *s - '0'; s++; } while (s < e && *s >= '0' && *s <= '9') { n = 10*n + (*s - '0'); ++s; } n *= sign; return true; } /// Read an integer. This functions does not read beyond the end of /// 'sp' (i.e. 'se') and does not read more that expectmax /// characters. If the number of characters read is smaller than /// 'expectmin' the function raises an exception. inline uint64_t readInt(const char*& sp, const char* const se, const int expectmin, const int expectmax) { const char* s = sp; int res = 0; int i; for (i=0; i= '0' && *sp <= '9') { res = 10 * res + *sp++ - 0x30; } else { break; } } if (sp - s >= expectmin) { return res; } else { throw std::range_error("cannot parse datetime element"); } } inline const std::string readString(const char*& sp, const char* const se) { const char* const s = sp; while (sp < se) { if ((*sp >= 'A' && *sp <= 'Z') || (*sp >= 'a' && *sp <= 'z') || (*sp == '_') || (*sp >= '/' && *sp <= '9')) { ++sp; } else { break; } } if (sp > s) { return std::string(s, sp-s); } else { throw std::range_error("cannot parse datetime timezone"); // # nocov } } inline void skipWhitespace(const char*& sp, const char* const se) { while (sp < se) { if (*sp == ' ' || *sp == '\t') { ++sp; } else { break; } } } struct tmdet { unsigned y; unsigned m; unsigned d; unsigned hh; unsigned mm; unsigned ss; std::int64_t ns; std::string tzstr; std::int64_t offset; }; inline tmdet readDtime(const char*& sp, const char* const se) { try { const unsigned y = readInt(sp, se, 4, 4); if (*sp == ' ' || *sp == '-' || *sp == '/') ++sp; const unsigned m = readInt(sp, se, 2, 2); if (*sp == ' ' || *sp == '-' || *sp == '/') ++sp; const unsigned d = readInt(sp, se, 2, 2); skipWhitespace(sp, se); if (sp < se && *sp == 'T') ++sp; unsigned h, mn, s; if (isdigit(*sp) || *(sp-1) == 'T') { // the time is optional h = readInt(sp, se, 2, 2); if (*sp == ':') ++sp; mn = readInt(sp, se, 2, 2); if (*sp == ':') ++sp; s = readInt(sp, se, 2, 2); } else { h = mn = s = 0; } // optional fractional part std::int64_t mul = 100000000; std::int64_t ns = 0; if (*sp == '.') { ++sp; unsigned i = 0; while (sp < se && mul >= 1) { if ((i == 3 || i == 6) && *sp == '_') { ++sp; continue; } ++i; if (!isdigit(*sp)) break; ns += (*sp - '0') * mul; mul /= 10; ++sp; } } skipWhitespace(sp, se); // not as much as we could test, but good enough without too much of // a performance hit: if (m < 1 || m > 12) throw std::range_error("month must be >= 1 and <= 12"); if (d < 1 || d > 31) throw std::range_error("day must be >= 1 and <= 31"); if (h > 23) throw std::range_error("hour must be < 24"); if (mn > 59) throw std::range_error("minute must be < 60"); if (s > 59) throw std::range_error("second must be < 60"); // debatable // optional offset std::string tzstr_str; // need to persist this copy! std::int64_t offset = 0; if (*sp == '+' || *sp == '-') { int64_t sign = *sp == '-' ? -1 : 1; int64_t h_offset = readInt(++sp, se, 2, 2); if (*sp != ':' && *sp != ' ') { throw std::range_error("Error parsing offset"); } int64_t m_offset = readInt(++sp, se, 2, 2); offset = sign * h_offset * 3600 + m_offset * 60; tzstr_str = "UTC"; } else if (isalpha(*sp)) { // or timezone tzstr_str = readString(sp, se); } skipWhitespace(sp, se); if (tzstr_str == "Z") { // consider "Z" a shorhand for "UTC" tzstr_str = "UTC"; // #nocov } return tmdet{y, m, d, h, mn, s, ns, tzstr_str, offset}; } catch(std::exception &ex) { forward_exception_to_r(ex); } catch(...) { ::Rf_error("c++ exception (unknown reason)"); } // not reached: return tmdet{0, 0, 0, 0, 0, 0, 0, "", 0};; } template void subset_numeric(const Rcpp::Vector& v, const I& pindx, Rcpp::Vector& res, std::vector& res_c, getNA fna) { if (!v.hasAttribute("names")) { for (R_xlen_t i = 0; i < pindx.size(); i++) { auto ii = pindx[i]; if (ii < 0) { Rcpp::stop("only 0's may be mixed with negative subscripts"); // #nocov } if (0 < ii && ii <= v.length()) { ii--; res_c.push_back(v[ii]); } else if (ii != 0) { /* out of bounds or NA */ res_c.push_back(fna()); } } res = Rcpp::Vector(res_c.size()); for (uint64_t i = 0; i < res_c.size(); i++) { res[i] = res_c[i]; } } else { // repeat the code, but subsetting names at the same time: const auto& names = Rcpp::CharacterVector(v.names()); auto names_c = std::vector(); static const char* NA_STRING_LOCAL = "dummy"; // so we can keep track of NA for (R_xlen_t i = 0; i < pindx.size(); i++) { auto ii = pindx[i]; if (ii < 0) { Rcpp::stop("only 0's may be mixed with negative subscripts"); // #nocov } if (0 < ii && ii <= v.length()) { ii--; res_c.push_back(v[ii]); names_c.push_back(Rcpp::CharacterVector::is_na(names[ii]) ? NA_STRING_LOCAL : names[ii]); } else if (ii != 0) { /* out of bounds or NA */ res_c.push_back(fna()); names_c.push_back(NA_STRING_LOCAL); } } res = Rcpp::Vector(res_c.size()); auto res_names = Rcpp::CharacterVector(res.size()); for (uint32_t i = 0; i < res_c.size(); i++) { res[i] = res_c[i]; if (names_c[i] == NA_STRING_LOCAL) { res_names[i] = NA_STRING; } else { res_names[i] = names_c[i]; } } res.names() = res_names; } } template void subset_logical(const Rcpp::Vector& v, const I& pindx, Rcpp::Vector& res, std::vector& res_c, getNA fna) { if (!v.hasAttribute("names")) { for (R_xlen_t i = 0; i < v.size(); i++) { if (pindx[i] == NA_LOGICAL) { res_c.push_back(fna()); } else if (pindx[i]) { res_c.push_back(v[i]); } } res = Rcpp::Vector(res_c.size()); for (uint64_t i = 0; i < res_c.size(); i++) { res[i] = res_c[i]; } } else { // repeat the code, but also subsetting names: const auto& names = Rcpp::CharacterVector(v.names()); auto names_c = std::vector(); static const char* NA_STRING_LOCAL = "dummy"; // so we can keep track of NA for (R_xlen_t i = 0; i < v.size(); i++) { if (pindx[i] == NA_LOGICAL) { res_c.push_back(fna()); names_c.push_back(NA_STRING_LOCAL); } else if (pindx[i]) { res_c.push_back(v[i]); names_c.push_back(names[i]); } } res = Rcpp::Vector(res_c.size()); auto res_names = Rcpp::CharacterVector(res.size()); for (uint32_t i = 0; i < res_c.size(); i++) { res[i] = res_c[i]; if (names_c[i] == NA_STRING_LOCAL) { res_names[i] = NA_STRING; } else { res_names[i] = names_c[i]; } } res.names() = res_names; } } const int64_t NA_INTEGER64 = std::numeric_limits::min(); const int MAX_TZ_STR_LENGTH = 1000; } // end namespace nanotime namespace nanotime_ops { /// This set of functors, to the contrary of the stdlib, allow /// operations where the operands and the results are of different /// types. This is handy for example is adding duration to time /// points, etc. template struct plus { inline R operator()(const T& t, const U& u) const { return t + u; } }; template struct minus { inline R operator()(const T& t, const U& u) const { return t - u; } }; template struct multiplies { inline R operator()(const T& t, const U& u) const { return t * u; } }; template struct divides { inline R operator()(const T& t, const U& u) const { return t / u; } }; } #endif nanotime/inst/tinytest/0000755000176200001440000000000014323545236014733 5ustar liggesusersnanotime/inst/tinytest/test_nanoperiod.R0000644000176200001440000013255614211166045020260 0ustar liggesusers suppressMessages({ library(nanotime) library(bit64) }) isSolaris <- Sys.info()[["sysname"]] == "SunOS" ## constructors ##test_as.nanoperiod_character <- function() { p1 <- as.nanoperiod("1m1d") expect_identical(nanoperiod.day(p1), 1) expect_identical(nanoperiod.month(p1), 1) expect_identical(nanoperiod.nanoduration(p1), as.nanoduration(0)) expect_identical(as.nanoperiod("1y"), as.nanoperiod("12m")) expect_identical(as.nanoperiod("2y"), as.nanoperiod("24m")) expect_identical(as.nanoperiod("1w"), as.nanoperiod("7d")) expect_identical(as.nanoperiod("2w"), as.nanoperiod("14d")) p2 <- as.nanoperiod("2m1d/00:01:01.1") expect_identical(nanoperiod.month(p2), 2) expect_identical(nanoperiod.day(p2), 1) expect_identical(nanoperiod.nanoduration(p2), as.nanoduration("00:01:01.1")) p3 <- as.nanoperiod(c("1d","2d","3d")) expect_identical(nanoperiod.day(p3[1]), 1) expect_identical(nanoperiod.day(p3[2]), 2) expect_identical(nanoperiod.day(p3[3]), 3) expect_identical(nanoperiod(), as.nanoperiod(NULL)) expect_identical(nanoperiod(), as.nanoperiod()) expect_identical(length(nanoperiod()), 0L) expect_identical(length(as.nanoperiod(NULL)), 0L) ## check year and week expect_identical(as.character(as.nanoperiod("1y/00:01:01")), "12m0d/00:01:01") expect_identical(as.character(as.nanoperiod("1w/00:01:01")), "0m7d/00:01:01") expect_identical(names(as.nanoperiod(c(a="1m"))), "a") ## check negative duration expect_identical(as.nanoperiod("-00:00:01"), as.nanoperiod(as.nanoduration("-00:00:01"))) expect_identical(as.nanoperiod("-0:00:01"), as.nanoperiod(as.nanoduration("-00:00:01"))) ##test_as.nanoperiod_character_error <- function() { expect_error(as.nanoperiod("1wm00:01:01"), "cannot parse nanoperiod") expect_error(as.nanoperiod("1ym00:01:01"), "cannot parse nanoperiod") expect_error(as.nanoperiod("1dm00:01:01"), "cannot parse nanoperiod") ##test_as.nanoperiod_integer64 <- function() { p1 <- as.nanoperiod(as.integer64(1:10)) expect_identical(nanoperiod.nanoduration(p1), as.nanoduration(1:10)) p1 <- as.nanoperiod(c(a=as.integer64(1))) expect_identical(nanoperiod.nanoduration(p1), as.nanoduration(c(a=1))) ##test_as.nanoperiod_integer <- function() { p1 <- as.nanoperiod(1:10) expect_identical(nanoperiod.nanoduration(p1), as.nanoduration(1:10)) p1 <- as.nanoperiod(c(a=1L)) expect_identical(nanoperiod.nanoduration(p1), as.nanoduration(c(a=1))) ##test_as.nanoperiod_numeric <- function() { p1 <- as.nanoperiod(as.numeric(1:10)) expect_identical(nanoperiod.nanoduration(p1), as.nanoduration(1:10)) p1 <- as.nanoperiod(c(a=1)) expect_identical(nanoperiod.nanoduration(p1), c(a=as.nanoduration(1))) ##test_as.nanoperiod_nanoduration <- function() { p1 <- as.nanoperiod(c(a=as.nanoduration(1))) expect_identical(p1, c(a=as.nanoperiod("00:00:00.000_000_001"))) ##test_nanoperiod <- function() { expect_identical(nanoperiod(0,0,1), as.nanoperiod(1)) expect_identical(nanoperiod(0,0,1:10), as.nanoperiod(1:10)) expect_identical(nanoperiod(1,1,0:9), as.nanoperiod(paste0("1m1d/00:00:00.000_000_00", 0:9))) expect_error(nanoperiod("a"), "argument 'months' must be numeric") expect_error(nanoperiod(1, "a"), "argument 'days' must be numeric") ## accessors: ##test_nanoperiod.day <- function() { p1 <- as.nanoperiod(paste0(1:10, "d")) names(p1) <- 1:10 expected <- as.numeric(1:10) names(expected) <- 1:10 expect_identical(nanoperiod.day(p1), expected) ##test_nanoperiod.month <- function() { p1 <- as.nanoperiod(paste0(1:10, "m")) names(p1) <- 1:10 expected <- as.numeric(1:10) names(expected) <- 1:10 expect_identical(nanoperiod.month(p1), expected) ##test_nanoperiod.nanoduration <- function() { p1 <- as.nanoperiod(1:10) names(p1) <- 1:10 expected <- as.numeric(1:10) names(expected) <- 1:10 expect_identical(nanoperiod.nanoduration(p1), as.nanoduration(expected)) ## show/print/as.character/format ##test_show <- function() { p1 <- format(as.nanoperiod("1m1d/1:00:00.1")) expect_identical(p1, "1m1d/01:00:00.100") expect_stdout(show(as.nanoperiod("1m1d/1:00:00.1"))) ##test_print <- function() { p1 <- format(as.nanoperiod("2m2d/2:02:02.2")) expect_identical(p1, "2m2d/02:02:02.200") expect_stdout(print(nanoperiod())) ##test_as.character <- function() { p1 <- as.character(as.nanoperiod("2m2d/2:02:02.20001")) expect_identical(p1, "2m2d/02:02:02.200_010") expect_identical(as.character(NA_nanoperiod_), NA_character_) ##test_as.character_named <- function() { p1 <- as.character(c(a=as.nanoperiod("2m2d/2:02:02.20001"), b=as.nanoperiod("2m2d/2:02:02.20002"))) expect_identical(p1, c(a="2m2d/02:02:02.200_010", b="2m2d/02:02:02.200_020")) ##test_format <- function() { p1 <- as.nanoperiod("2m2d/2:02:02.20001") expect_identical(format(p1), "2m2d/02:02:02.200_010") expect_identical(as.character(p1), "2m2d/02:02:02.200_010") ## subset: ##test_subset_int <- function() { p1 <- as.nanoperiod("1m1d/00:00:01") p2 <- as.nanoperiod("2m2d/00:00:02") p3 <- as.nanoperiod("3m3d/00:00:03") p4 <- as.nanoperiod("4m4d/00:00:04") pp <- c(p1, p2, p3, p4) expect_identical(pp[1], p1) expect_identical(pp[2], p2) expect_identical(pp[3], p3) expect_identical(pp[4], p4) expect_identical(pp[1:4], pp) expect_identical(pp[2:3], c(p2,p3)) expect_identical(pp[-1:-2], c(p3,p4)) expect_warning(pp[1, 2], "unused indices or arguments in 'nanoperiod' subsetting") ##test_subset_logical <- function() { p1 <- as.nanoperiod("1m1d/00:00:01") p2 <- as.nanoperiod("2m2d/00:00:02") p3 <- as.nanoperiod("3m3d/00:00:03") p4 <- as.nanoperiod("4m4d/00:00:04") pp <- c(p1, p2, p3, p4) expect_identical(pp[c(T,F,F,F)], p1) expect_identical(pp[c(F,T,F,F)], p2) expect_identical(pp[c(F,F,T,F)], p3) expect_identical(pp[c(F,F,F,T)], p4) expect_identical(pp[TRUE], pp) expect_identical(pp[c(F,T,T,F)], c(p2,p3)) expect_identical(pp[c(NA, F, F, F)], as.nanoperiod(NA_integer_)) expect_identical(pp[c(NA, F, F, F)], NA_nanoperiod_) expect_warning(pp[T, F], "unused indices or arguments in 'nanoperiod' subsetting") ##test_subset_character <- function() { pp <- c(x=as.nanoperiod(1), y=as.nanoperiod(2)) expect_identical(pp["x"], c(x=as.nanoperiod(1))) expect_identical(pp["y"], c(y=as.nanoperiod(2))) res <- NA_nanoperiod_ names(res) <- NA_character_ expect_identical(pp["a"], res) expect_warning(pp["a", "b"], "unused indices or arguments in 'nanoperiod' subsetting") ## test subset incorrect type expect_error(pp[as.integer64(1)], "']' not defined on 'nanoperiod' for index of type 'ANY'") ## subassign ##test_subassign_logical <- function() { x <- as.nanoperiod(1:10) x[c(T,T,T,F,F,F,F,F,F,F)] <- as.nanoperiod(2:4) expect_identical(x, as.nanoperiod(c(2:4, 4:10))) x <- as.nanoperiod(paste0(1:10, "d")) x[c(T,T,T,F,F,F,F,F,F,F)] <- as.nanoperiod(paste0(2:4, "d")) expect_identical(x, as.nanoperiod(paste0(c(2:4, 4:10), "d"))) ##test_subassign_numeric <- function() { x <- as.nanoperiod(1:10) x[1:3] <- as.nanoperiod(2:4) x[4:10] <- as.nanoperiod(5:11) expect_identical(x, as.nanoperiod(2:11)) x <- as.nanoperiod(paste0(1:10, "d")) x[1:3] <- as.nanoperiod(paste0(2:4, "d")) x[4:10] <- as.nanoperiod(paste0(5:11, "d")) expect_identical(x, as.nanoperiod(paste0(2:11, "d"))) ##test_subsassign_character <- function() { pp <- c(a=as.nanoperiod(1), b=as.nanoperiod(2), c=as.nanoperiod(3), d=as.nanoperiod(4)) pp[c("b", "c")] <- as.nanoperiod(20:21) expected <- c(a=as.nanoperiod(1), b=as.nanoperiod(20), c=as.nanoperiod(21), d=as.nanoperiod(4)) expect_identical(pp, expected) ##test_square_bracket <- function() { pp <- c(a=as.nanoperiod(1), b=as.nanoperiod(2), c=as.nanoperiod(3), d=as.nanoperiod(4)) pp_nonames <- as.nanoperiod(1:4) expect_identical(pp_nonames[1], pp[[1]]) expect_identical(pp_nonames[2], pp[[2]]) expect_identical(pp_nonames[3], pp[[3]]) ## ops ## - ##test_nanoperiod_minus_nanoperiod <- function() { expect_identical(-as.nanoperiod("2m2d/00:00:02"), as.nanoperiod("-2m-2d/-00:00:02")) expect_identical(as.nanoperiod("2m2d") - as.nanoperiod("1m1d"), as.nanoperiod("1m1d")) expect_identical(as.nanoperiod("-1m-1d/-00:00:01") - as.nanoperiod("1m1d/00:00:01"), as.nanoperiod("-2m-2d/-00:00:02")) ##test_nanoperiod_minus_nanoperiod_vector <- function() { expect_identical(as.nanoperiod("1d") - as.nanoperiod(paste0(1:10, "d")), as.nanoperiod(paste0(0:-9,"d"))) expect_identical(as.nanoperiod(paste0(1:10, "d")) - as.nanoperiod("1d"), as.nanoperiod(paste0(0:9,"d"))) expect_identical(as.nanoperiod(paste0(1:10, "d")) - as.nanoperiod(paste0(0:9, "d")), as.nanoperiod(paste0(rep(1,10),"d"))) ##test_nanoperiod_minus_numeric <- function() { expect_identical(as.nanoperiod("2m2d") - 1, as.nanoperiod("2m2d/-00:00:00.000_000_001")) expect_identical(as.nanoperiod(paste0(1:10,"m2d")) - 1, as.nanoperiod(paste0(1:10, "m2d/-00:00:00.000_000_001"))) expect_identical(as.nanoperiod("12m2d") - 1:9.0, as.nanoperiod(paste0("12m2d/-00:00:00.000_000_00", 1:9))) ##test_nanoperiod_minus_nanoduration <- function() { expect_identical(as.nanoperiod("2m2d") - as.nanoduration(1), as.nanoperiod("2m2d/-00:00:00.000_000_001")) expect_identical(as.nanoperiod(paste0(1:10,"m2d")) - as.nanoduration(1), as.nanoperiod(paste0(1:10, "m2d/-00:00:00.000_000_001"))) expect_identical(as.nanoperiod("12m2d") - as.nanoduration(1:9), as.nanoperiod(paste0("12m2d/-00:00:00.000_000_00", 1:9))) ##test_nanoperiod_minus_integer <- function() { expect_identical(as.nanoperiod("2m2d") - as.integer(1), as.nanoperiod("2m2d/-00:00:00.000_000_001")) expect_identical(as.nanoperiod(paste0(1:10,"m2d")) - as.integer(1), as.nanoperiod(paste0(1:10, "m2d/-00:00:00.000_000_001"))) expect_identical(as.nanoperiod("12m2d") - as.integer(1:9), as.nanoperiod(paste0("12m2d/-00:00:00.000_000_00", 1:9))) ##test_nanoperiod_minus_integer64 <- function() { expect_identical(as.nanoperiod("2m2d") - as.integer64(1), as.nanoperiod("2m2d/-00:00:00.000_000_001")) expect_identical(as.nanoperiod(paste0(1:10,"m2d")) - as.integer64(1), as.nanoperiod(paste0(1:10, "m2d/-00:00:00.000_000_001"))) expect_identical(as.nanoperiod("12m2d") - as.integer64(1:9), as.nanoperiod(paste0("12m2d/-00:00:00.000_000_00", 1:9))) ##test_numeric_minus_nanoperiod <- function() { expect_identical(1 - as.nanoperiod("1m1d"), as.nanoperiod("-1m-1d/00:00:00.000_000_001")) expect_identical(1:10 - as.nanoperiod("1m1d"), nanoperiod(-1,-1,1:10)) expect_identical(1 - nanoperiod(1:10,1,1), nanoperiod(-1:-10, -1, 0)) ##test_integer64_minus_nanoperiod <- function() { expect_identical(as.integer64(1) - as.nanoperiod("1m1d"), as.nanoperiod("-1m-1d/00:00:00.000_000_001")) expect_identical(as.integer64(1:10) - as.nanoperiod("1m1d"), nanoperiod(-1,-1,1:10)) expect_identical(as.integer64(1) - nanoperiod(1:10,1,1), nanoperiod(-1:-10, -1, 0)) ##test_nanoduration_minus_nanoperiod <- function() { expect_identical(as.nanoduration(1) - as.nanoperiod("1m1d"), as.nanoperiod("-1m-1d/00:00:00.000_000_001")) expect_identical(as.nanoduration(1:10) - as.nanoperiod("1m1d"), nanoperiod(-1,-1,1:10)) expect_identical(as.nanoduration(1) - nanoperiod(1:10,1,1), nanoperiod(-1:-10, -1, 0)) ##test_nanoperiod_minus_any <- function() { expect_error(as.nanoperiod(1) - "a", "invalid operand types") ##test_any_minus_nanoperiod <- function() { expect_error("a" - as.nanoperiod(1), "invalid operand types") expect_error(as.nanoperiod(1) - nanotime(1), "invalid operand types") ## + ##test_nanoperiod_plus_nanoperiod <- function() { expect_identical(+as.nanoperiod("2m"), as.nanoperiod("2m")) expect_identical(as.nanoperiod("2m2d") + as.nanoperiod("1m1d"), as.nanoperiod("3m3d")) expect_identical(as.nanoperiod("-1m-1d/00:00:01") + as.nanoperiod("1m1d/00:00:01"), as.nanoperiod("0m0d/00:00:02")) expect_identical(nanoperiod(1,1,1:10) + nanoperiod(1,1,0), nanoperiod(2,2,1:10)) expect_identical(nanoperiod(1,1,0) + nanoperiod(1,1,1:10), nanoperiod(2,2,1:10)) ##test_nanoperiod_plus_nanoperiod_names <- function() { non_scalar <- as.nanoperiod(c(a="2m2d", b="3m3d")) scalar <- as.nanoperiod(c(c="1m1d")) expected <- as.nanoperiod(c(a="3m3d", b="4m4d")) expect_identical(non_scalar + scalar, expected) expect_identical(scalar + non_scalar, expected) ##test_integer64_plus_nanoperiod <- function() { expect_identical(as.integer64(1) + as.nanoperiod(1), as.nanoperiod(2)) expect_identical(as.integer64(0:9) + as.nanoperiod(1), as.nanoperiod(1:10)) expect_identical(as.integer64(1) + nanoperiod(1:10,1,0), nanoperiod(1:10,1,1)) ##test_nanoperiod_plus_integer64 <- function() { expect_identical(as.nanoperiod(1) + as.integer64(1), as.nanoperiod(2)) expect_identical(as.nanoperiod("2m2d") + as.integer64(1), as.nanoperiod("2m2d/00:00:00.000_000_001")) expect_identical(as.nanoperiod(1) + as.integer64(0:9), as.nanoperiod(1:10)) expect_identical(nanoperiod(1:10,1,0) + as.integer64(1), nanoperiod(1:10,1,1)) ##test_nanoperiod_plus_nanoduration <- function() { expect_identical(as.nanoperiod(1) + as.nanoduration(1), as.nanoperiod(2)) expect_identical(as.nanoperiod("2m2d") + as.nanoduration(1), as.nanoperiod("2m2d/00:00:00.000_000_001")) expect_identical(as.nanoperiod(1) + as.nanoduration(0:9), as.nanoperiod(1:10)) expect_identical(nanoperiod(1:10,1,0) + as.nanoduration(1), nanoperiod(1:10,1,1)) ##test_nanoduration_plus_nanoperiod <- function() { expect_identical(as.nanoduration(1) + as.nanoperiod(1), as.nanoperiod(2)) expect_identical(as.nanoduration(1) + as.nanoperiod("2m2d"), as.nanoperiod("2m2d/00:00:00.000_000_001")) expect_identical(as.nanoduration(0:9) + as.nanoperiod(1), as.nanoperiod(1:10)) expect_identical(as.nanoduration(1) + nanoperiod(1:10,1,0), nanoperiod(1:10,1,1)) ##test_numeric_plus_nanoperiod <- function() { expect_identical(as.nanoperiod(1) + 1, as.nanoperiod(2)) expect_identical(as.nanoperiod("2m2d") + 1, as.nanoperiod("2m2d/00:00:00.000_000_001")) expect_identical(0.0:9.0 + as.nanoperiod(1), as.nanoperiod(1:10)) expect_identical(1.0 + nanoperiod(1:10,1,0), nanoperiod(1:10,1,1)) ##test_any_plus_nanoperiod <- function() { expect_error("a" + as.nanoperiod(1), "invalid operand types") ##test_nanoperiod_plus_any <- function() { expect_error(as.nanoperiod(1) + any, "invalid operand types") ## * ##test_nanoperiod_times_numeric <- function() { expect_identical(as.nanoperiod(1) * 3, as.nanoperiod(3)) expect_identical(as.nanoperiod("1m1d") * 3, as.nanoperiod("3m3d")) expect_identical(nanoperiod(1,1,1) * 1:10, nanoperiod(1:10,1:10,1:10)) expect_identical(nanoperiod(1:10,1,1) * 3, nanoperiod(1:10 * 3, 3, 3)) ##test_nanoperiod_times_integer64 <- function() { expect_identical(as.nanoperiod(1) * as.integer64(3), as.nanoperiod(3)) expect_identical(nanoperiod(1,1,1) * as.integer64(1:10), nanoperiod(1:10,1:10,1:10)) expect_identical(nanoperiod(1:10,1,1) * as.integer64(3), nanoperiod(1:10 * 3, 3, 3)) ##test_numeric_times_nanoperiod <- function() { expect_identical(3 * as.nanoperiod(1), as.nanoperiod(3)) expect_identical(4.5 * as.nanoperiod("10d"), as.nanoperiod("45d")) expect_identical(1:10.0 * as.nanoperiod(1), as.nanoperiod(1:10)) expect_identical(1 * as.nanoperiod(1:10), as.nanoperiod(1:10)) ##test_integer64_times_nanoperiod <- function() { expect_identical(as.integer64(3) * as.nanoperiod(1), as.nanoperiod(3)) expect_identical(as.integer64(3) * as.nanoperiod("1m1d"), as.nanoperiod("3m3d")) expect_identical(as.integer64(1:10) * as.nanoperiod(1), as.nanoperiod(1:10)) expect_identical(as.integer64(1) * as.nanoperiod(1:10), as.nanoperiod(1:10)) ##test_character_times_nanoperiod <- function() { expect_error("a" * as.nanoperiod(1), "invalid operand types") expect_error("123" * as.nanoperiod(1), "invalid operand types") ##test_nanoperiod_times_character <- function() { expect_error(as.nanoperiod(1) * "a", "invalid operand types") expect_error(as.nanoperiod(1) * "123", "invalid operand types") ## / ##test_nanoperiod_div_numeric <- function() { expect_identical(as.nanoperiod(4) / 3, as.nanoperiod(1)) expect_identical(as.nanoperiod("5m5d") / 2.5, as.nanoperiod("2m2d")) expect_identical(as.nanoperiod(4) / c(4,2,1), as.nanoperiod(c(1,2,4))) expect_identical(as.nanoperiod(4:2) / c(4,2,1), as.nanoperiod(c(1,1,2))) expect_error(as.nanoperiod("2m") / 0, "divide by zero") ##test_nanoperiod_div_integer64 <- function() { expect_identical(as.nanoperiod(4) / as.integer64(3), as.nanoperiod(1)) expect_identical(as.nanoperiod("5m5d") / as.integer64(2), as.nanoperiod("2m2d")) expect_identical(as.nanoperiod(4) / as.integer64(c(4,2,1)), as.nanoperiod(c(1,2,4))) expect_identical(as.nanoperiod(4:2) / as.integer64(c(4,2,1)), as.nanoperiod(c(1,1,2))) ##test_nanoperiod_div_integer <- function() { expect_identical(as.nanoperiod(4) / as.integer(3), as.nanoperiod(1)) expect_identical(as.nanoperiod("5m5d") / as.integer(2), as.nanoperiod("2m2d")) expect_identical(as.nanoperiod(4) / as.integer(c(4,2,1)), as.nanoperiod(c(1,2,4))) expect_identical(as.nanoperiod(4:2) / as.integer(c(4,2,1)), as.nanoperiod(c(1,1,2))) ##test_nanoperiod_div_any <- function() { expect_error(as.nanoperiod(1) / "a", "invalid operand types") ##test_any_div_nanoperiod <- function() { expect_error("a" / as.nanoperiod(1), "invalid operand types") ##test_Logic_nanoperiod_any <- function() { expect_error(as.nanoperiod(1) | "a", "operation not defined for 'nanoperiod' objects") ##test_Logic_any_nanoperiod <- function() { expect_error("a" | as.nanoperiod(1), "operation not defined for 'nanoperiod' objects") ## Math/Math2/Summary/Complex ##test_nanoperiod_Math <- function() { ## is that right? LLL expect_error(abs(as.nanoperiod(1)), "operation not defined for 'nanoperiod' objects") ##test_nanoperiod_Math2 <- function() { expect_error(round(as.nanoperiod(1)), "operation not defined for 'nanoperiod' objects") ##test_nanoperiod_Summary <- function() { expect_error(min(as.nanoperiod(1)), "invalid 'type' \\(nanoperiod\\) of argument") expect_error(max(as.nanoperiod(1)), "invalid 'type' \\(nanoperiod\\) of argument") ##test_nanoperiod_Complex <- function() { expect_error(Arg(as.nanoperiod(1)), "operation not defined for 'nanoperiod' objects") ##test_binary_plus_nanoperiod_nanotime <- function() { expect_error(as.nanoperiod(1) + nanotime(1), "binary '\\+' is not defined for 'nanoperiod' and 'nanotime' objects; instead use 'plus\\(e1, e2, tz\\)'") ##test_binary_plus_nanotime_nanoperiod <- function() { expect_error(nanotime(1) + as.nanoperiod(1), "binary '\\+' is not defined for 'nanotime' and 'nanoperiod' objects; instead use 'plus\\(e1, e2, tz\\)'") ##test_binary_plus_nanoperiod_nanoival <- function() { expect_error(as.nanoperiod(1) + nanoival(nanotime(1), nanotime(2)), "binary '\\+' is not defined for 'nanoperiod' and 'nanoival' objects; instead use 'plus\\(e1, e2, tz\\)'") ##test_binary_plus_nanoival_nanoperiod <- function() { expect_error(nanoival(nanotime(1), nanotime(2)) + as.nanoperiod(1), "binary '\\+' is not defined for 'nanoival' and 'nanoperiod' objects; instead use 'plus\\(e1, e2, tz\\)'") ## Compare ## ---------- ##test_nanoperiod_eq_nanoperiod <- function() { expect_true(as.nanoperiod(1) == as.nanoperiod(1)) expect_true(as.nanoperiod("1d") == as.nanoperiod("1d")) expect_true(!(as.nanoperiod(1) == as.nanoperiod(2))) expect_identical(as.nanoperiod(1:10) == as.nanoperiod(1:10), rep(TRUE, 10)) ##test_nanoperiod_ne_nanoperiod <- function() { expect_true(as.nanoperiod(1) != as.nanoperiod(2)) expect_true(as.nanoperiod("1d") != as.nanoperiod("2d")) expect_true(!(as.nanoperiod(1) != as.nanoperiod(1))) expect_identical(as.nanoperiod(1:10) != as.nanoperiod(1:10), rep(FALSE, 10)) ##test_nanoperiod_eq_any <- function() { expect_error(as.nanoperiod(1) == "a", "operation not defined for 'nanoperiod' objects") ##test_any_eq_nanoperiod <- function() { expect_error("a" == as.nanoperiod(1), "operation not defined for 'nanoperiod' objects") ##test_all.equal <- function() { expect_true(all.equal(as.nanoperiod(1), as.nanoperiod(1))) expect_true(all.equal(as.nanoperiod(1:10), as.nanoperiod(1:10))) expect_true(all.equal(as.nanoperiod("1m1d"), as.nanoperiod("1d") + as.nanoperiod("1m"))) ## names (in general) ##test_nanoperiod_get_names <- function() { a <- as.nanoperiod(1:10) names(a) <- "b" expect_identical(names(a), c("b", rep(as.character(NA), 9))) ##test_nanoperiod_set_names <- function() { names <- c("a","b","c","d") pp <- as.nanoperiod(1:4) names(pp) <- names expect_identical(names(pp), names) names(pp)[1] <- "x" expect_identical(names(pp), c("x","b","c","d")) ##test_nanoperiod_c <- function() { pp <- c(x=as.nanoperiod(1), y=as.nanoperiod(2)) expect_identical(names(pp), c("x","y")) expect_identical(pp[1], c(x=as.nanoperiod(1))) expect_identical(pp[2], c(y=as.nanoperiod(2))) pp <- c(as.nanoperiod(1:10), as.nanoperiod(11:20)) expect_identical(pp, as.nanoperiod(1:20)) if (!isSolaris) { ## plus/minus with 'nanotime': ##test_plus_nanotime_nanoperiod <- function() { nt <- nanotime("2018-01-01T05:00:00.000000000+00") p <- c(p=as.nanoperiod("4m")) tz <- "America/New_York" expected <- c(p=nanotime("2018-05-01T00:00:00.000000000-04:00")) expect_identical(plus(nt, p, tz), expected) ##test_plus_nanotime_nanoperiod_vector1 <- function() { nt <- nanotime("2018-01-01T05:00:00.000000000+00") + 1:10 p <- as.nanoperiod("4m") tz <- "America/New_York" expected <- nanotime("2018-05-01T00:00:00.000000000-04:00") + 1:10 expect_identical(plus(nt, p, tz), expected) ##test_plus_nanotime_nanoperiod_vector2 <- function() { nt <- nanotime("2018-01-01T05:00:00.000000000+00") p <- as.nanoperiod("4m") + 1:10 tz <- "America/New_York" expected <- nanotime("2018-05-01T00:00:00.000000000-04:00") + 1:10 expect_identical(plus(nt, p, tz), expected) ##test_plus_nanotime_nanoperiod_vector3 <- function() { nt <- nanotime("2018-01-01T05:00:00.000000000+00") p <- as.nanoperiod("4m") + 1:10 tz <- rep("America/New_York", 10) expected <- nanotime("2018-05-01T00:00:00.000000000-04:00") + 1:10 expect_identical(plus(nt, p, tz), expected) ##test_plus_nanoperiod_nanotime <- function() { nt <- nanotime("2018-01-01T05:00:00.000000000+00") p <- c(p=as.nanoperiod("4m")) tz <- "America/New_York" expected <- c(p=nanotime("2018-05-01T00:00:00.000000000-04:00")) expect_identical(plus(p, nt, tz), expected) ##test_minus_nanotime_nanoperiod <- function() { nt <- c(p1=nanotime("2018-05-01T00:00:00.000000000-04:00")) p <- c(p2=as.nanoperiod("4m")) tz <- "America/New_York" expected <- c(p1=nanotime("2018-01-01T00:00:00.000000000-05:00")) expect_identical(minus(nt, p, tz), expected) ##test_minus_nanoperiod_nanotime <- function() { nt <- nanotime("2018-05-01T00:00:00.000000000-04:00") p <- as.nanoperiod("4m") tz <- "America/New_York" expect_error(minus(p, nt, tz), "operation not defined for 'nanoperiod' objects") ## test the crossing of daylight saving time in both directions: ## adding/subtracting a nanoperiod should not realign if doing so ## crosses again a DST boundary: ## look at cases over the Spring boundary in America: nt <- as.nanotime("2020-03-08 01:45:30 America/New_York") p <- as.nanoperiod("00:30:00") tz <- "America/New_York" expected <- as.nanotime("2020-03-08 03:15:30 America/New_York") expect_identical(plus(nt, p, tz), expected) nt <- as.nanotime("2020-03-08 01:00:00 America/New_York") p <- as.nanoperiod("01:00:00") tz <- "America/New_York" expected <- as.nanotime("2020-03-08 03:00:00 America/New_York") expect_identical(plus(nt, p, tz), expected) nt <- as.nanotime("2020-03-08 03:15:30 America/New_York") p <- as.nanoperiod("00:30:00") tz <- "America/New_York" expected <- as.nanotime("2020-03-08 01:45:30 America/New_York") expect_identical(minus(nt, p, tz), expected) nt <- as.nanotime("2020-03-08 03:00:00 America/New_York") p <- as.nanoperiod("01:00:00") tz <- "America/New_York" expected <- as.nanotime("2020-03-08 01:00:00 America/New_York") expect_identical(minus(nt, p, tz), expected) ## look at the cases over the Autumn boundary in America: nt <- as.nanotime("2020-11-01 01:45:30 America/New_York") p <- as.nanoperiod("00:30:00") tz <- "America/New_York" expected <- as.nanotime("2020-11-01 02:15:30 America/New_York") expect_identical(plus(nt, p, tz), expected) nt <- as.nanotime("2020-11-01 01:00:00 America/New_York") p <- as.nanoperiod("01:00:00") tz <- "America/New_York" expected <- as.nanotime("2020-11-01 02:00:00 America/New_York") expect_identical(plus(nt, p, tz), expected) nt <- as.nanotime("2020-11-01 02:15:30 America/New_York") p <- as.nanoperiod("00:30:00") tz <- "America/New_York" ##expected <- as.nanotime("2020-11-01 01:45:30 America/New_York") # ambiguous expected <- as.nanotime("2020-11-01 06:45:30+00:00") expect_identical(minus(nt, p, tz), expected) nt <- as.nanotime("2020-11-01 02:00:00 America/New_York") p <- as.nanoperiod("01:00:00") tz <- "America/New_York" ## expected <- as.nanotime("2020-11-01 01:00:00 America/New_York") # ambiguous expected <- as.nanotime("2020-11-01 06:00:00+00:00") expect_identical(minus(nt, p, tz), expected) ## adding/subtracting a nanoperiod should realign if doing so does ## not cross again a DST boundary: ## look at cases over the Spring boundary in America: nt <- as.nanotime("2020-03-08 01:00:00 America/New_York") p <- as.nanoperiod("02:00:01") tz <- "America/New_York" expected <- as.nanotime("2020-03-08 03:00:01 America/New_York") expect_identical(plus(nt, p, tz), expected) nt <- as.nanotime("2020-03-08 03:00:00 America/New_York") p <- as.nanoperiod("02:00:01") tz <- "America/New_York" expected <- as.nanotime("2020-03-08 00:59:59 America/New_York") expect_identical(minus(nt, p, tz), expected) ## look at the cases over the Autumn boundary in America: nt <- as.nanotime("2020-11-01 01:00:00 America/New_York") p <- as.nanoperiod("02:00:01") tz <- "America/New_York" expected <- as.nanotime("2020-11-01 03:00:01 America/New_York") expect_identical(plus(nt, p, tz), expected) nt <- as.nanotime("2020-11-01 03:00:00 America/New_York") p <- as.nanoperiod("02:00:01") tz <- "America/New_York" expected <- as.nanotime("2020-11-01 00:59:59 America/New_York") expect_identical(minus(nt, p, tz), expected) ## plus/minus with 'nanoival': ##test_plus_nanoival_nanoperiod <- function() { start <- nanotime("2018-01-01T05:00:00.000000000+00") end <- nanotime("2018-01-01T23:00:00.000000000+00") ni <- nanoival(start, end) p <- as.nanoperiod("4m") tz <- "America/New_York" expected <- as.nanoival("+2018-05-01T00:00:00.000000000-04:00 -> 2018-05-01T18:00:00.000000000-04:00-") expect_identical(plus(ni, p, tz), expected) ##test_plus_nanoival_nanoperiod_pre_1970 <- function() { start <- nanotime("1969-01-01T05:00:00.000000000+00") end <- nanotime("1969-01-01T23:00:00.000000000+00") ni <- nanoival(start, end) p <- as.nanoperiod("4m") tz <- "America/New_York" expected <- as.nanoival("+1969-05-01T00:00:00.000000000-04:00 -> 1969-05-01T18:00:00.000000000-04:00-") expect_identical(plus(ni, p, tz), expected) ##test_plus_nanoperiod_nanoival <- function() { start <- nanotime("2018-01-01T05:00:00.000000000+00") end <- nanotime("2018-01-01T23:00:00.000000000+00") ni <- nanoival(start, end) p <- c(a=as.nanoperiod("4m")) tz <- "America/New_York" expected <- c(a=as.nanoival("+2018-05-01T00:00:00.000000000-04:00 -> 2018-05-01T18:00:00.000000000-04:00-")) expect_identical(plus(p, ni, tz), expected) ##test_minus_nanoival_nanoperiod <- function() { start <- nanotime("2018-05-01T05:00:00.000000000-04") end <- nanotime("2018-05-01T23:00:00.000000000-04") ni <- c(a=nanoival(start, end)) p <- as.nanoperiod("4m") tz <- "America/New_York" expected <- c(a=as.nanoival("+2018-01-01T05:00:00.000000000-05:00 -> 2018-01-01T23:00:00.000000000-05:00-")) expect_identical(minus(ni, p, tz), expected) ##test_minus_nanoperiod_nanoival <- function() { start <- nanotime("2018-05-01T05:00:00.000000000-04") end <- nanotime("2018-05-01T23:00:00.000000000-04") ni <- nanoival(start, end) p <- as.nanoperiod("4m") tz <- "America/New_York" expect_error(minus(p, ni, tz), "operation not defined for 'nanoperiod' objects") } ## NA stuff expect_true(is.na(as.nanoperiod(NA_integer_))) expect_true(is.na(as.nanoperiod(NA_integer64_))) expect_true(is.na(as.nanoperiod(NA_real_))) expect_true(is.na(as.nanoperiod(as.integer(NaN)))) p <- as.nanoperiod(1:10) is.na(p) <- 1:3 expect_true(all(is.na(p[1:3]))) expect_true(!any(is.na(p[4:10]))) expect_true(is.na(NA_nanoperiod_)) expect_true(is.na(nanoperiod.nanoduration(NA_nanoperiod_))) expect_true(is.na(nanoperiod.month(NA_nanoperiod_))) expect_true(is.na(nanoperiod.day(NA_nanoperiod_))) ## test S4 conversions: expect_identical(nanoperiod(1,1,1), as("1m1d/00:00:00.000_000_001", "nanoperiod")) hour <- 3600*1e9 expect_identical(as.nanoperiod(as.integer64(hour)), as(hour, "nanoperiod")) expect_identical(as.nanoperiod(hour), as(hour, "nanoperiod")) expect_identical(as.nanoperiod(hour), as(as.nanoduration(hour), "nanoperiod")) ## 0-length ops: ## ------------ ## constructor: expect_identical(nanoperiod(integer(), integer(), nanoduration()), nanoperiod()) expect_identical(nanoperiod(1, 1, nanoduration()), nanoperiod()) expect_identical(nanoperiod(1,integer(), as.nanoduration(1)), nanoperiod()) expect_identical(nanoperiod(numeric(), integer(), as.nanoduration(1)), nanoperiod()) ## Comp: expect_identical(as.nanoperiod() == as.nanoperiod(), logical()) expect_identical(as.nanoperiod(1) == as.nanoperiod(), logical()) expect_identical(as.nanoperiod(1) != as.nanoperiod(), logical()) ## ops expect_identical(as.nanoperiod() + as.nanoperiod(), as.nanoperiod()) expect_identical(nanoperiod(1) + as.nanoperiod(), as.nanoperiod()) expect_identical(nanoperiod() + as.nanoperiod(1:10), as.nanoperiod()) expect_identical(nanoperiod() + as.nanoduration(1:10), as.nanoperiod()) expect_identical(nanoperiod() + as.integer64(1:10), as.nanoperiod()) expect_identical(nanoperiod(1) + as.integer(), as.nanoperiod()) expect_identical(as.nanoperiod() - as.nanoperiod(), as.nanoperiod()) expect_identical(nanoperiod(1) - as.nanoperiod(), as.nanoperiod()) expect_identical(nanoperiod() - as.nanoperiod(1:10), as.nanoperiod()) expect_identical(nanoperiod() * 3, as.nanoperiod()) expect_identical(nanoperiod(1) * integer(), as.nanoperiod()) ## accessors expect_identical(nanoperiod.month(nanoperiod()), numeric()) expect_identical(nanoperiod.day(nanoperiod()), numeric()) expect_identical(nanoperiod.nanoduration(nanoperiod()), as.nanoduration()) ## all.equal: expect_identical(all.equal(as.nanoperiod("1m"), as.nanoperiod("1m")), TRUE) expect_false(isTRUE(all.equal(as.nanoperiod("1d"), "A"))) expect_identical(all.equal(as.nanoperiod("1d"), NA_nanoperiod_), "'is.NA' value mismatch: 1 in current 0 in target") ## test rounding functions: ## nano_ceiling: if (isSolaris) exit_file("skip remainder on Solaris") ## years: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), tz="America/New_York"), as.nanotime("2011-01-01T00:00:00-05:00")) expect_identical(nano_ceiling(as.nanotime("1970-01-01 America/New_York"), as.nanoperiod("12m"), tz="America/New_York"), as.nanotime("1970-01-01 America/New_York")) expect_identical(nano_ceiling(as.nanotime("1970-01-01 06:00:00 America/New_York"), as.nanoperiod("12m"), tz="America/New_York"), as.nanotime("1971-01-01 America/New_York")) expect_error(nano_ceiling(c(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanotime("2010-10-10 11:00:00 America/New_York")), as.nanoperiod("12m"), tz="America/New_York"), "'x' must be sorted") expect_error(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), tz=c("America/New_York", "UTC")), "'tz' must be scalar") expect_identical(nano_ceiling(as.nanotime("1940-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), tz="America/New_York"), as.nanotime("1941-01-01T00:00:00-05:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), origin=as.nanotime("2010-10-10 00:00:01 America/New_York"), tz="America/New_York"), as.nanotime("2011-10-10T04:00:01+00:00")) expect_error(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), origin=as.nanotime(1:10), tz="America/New_York"), "'origin' must be scalar") expect_identical(nano_ceiling(as.nanotime("1904-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), origin=as.nanotime("1904-10-10 00:00:01 America/New_York"), tz="America/New_York"), as.nanotime("1905-10-10T05:00:01+00:00")) expect_error(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), origin=as.nanotime("2004-10-10 00:00:01 America/New_York"), tz="America/New_York"), "when specifying 'origin', the first interval must contain at least one observation") expect_error(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoperiod("-12m"), tz="America/New_York"), "'precision' must be strictly positive") expect_error(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoperiod("-12m"), tz="America/New_York", origin="wrong type"), "'origin' must be of class 'nanotime'") expect_error(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoperiod("-12m"), tz=12), "'tz' must be of type 'character'") ## months: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("13m"), tz="America/New_York"), as.nanotime("2011-11-01T00:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-08-10 12:00:00 America/New_York"), as.nanoperiod("3m"), tz="America/New_York"), as.nanotime("2010-10-01T00:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-08-10 12:00:00 America/New_York"), as.nanoperiod("1m"), tz="America/New_York"), as.nanotime("2010-09-01T00:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("1940-08-10 12:00:00 America/New_York"), as.nanoperiod("1m"), tz="America/New_York"), as.nanotime("1940-09-01T00:00:00-04:00")) ## days: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("1d"), tz="America/New_York"), as.nanotime("2010-10-11T00:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("2d"), tz="America/New_York"), as.nanotime("2010-10-12T00:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("1940-10-10 12:00:00 America/New_York"), as.nanoperiod("2d"), tz="America/New_York"), as.nanotime("1940-10-12T00:00:00-05:00")) ## hours: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("06:00:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("1927-10-10 12:00:00 America/New_York"), as.nanoperiod("06:00:00"), tz="America/New_York"), as.nanotime("1927-10-10T12:00:00-05:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("01:00:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("06:00:00"), tz="America/New_York"), as.nanotime("2010-10-10T18:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("07:00:00"), tz="America/New_York"), as.nanotime("2010-10-10T19:00:00-04:00")) expect_identical(nano_ceiling(as.nanotime("1899-10-10 12:23:23 America/New_York"), as.nanoperiod("07:00:00"), tz="America/New_York"), as.nanotime("1899-10-10T19:00:00-05:00")) ## minutes: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("00:05:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:25:00-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:25:00 America/New_York"), as.nanoperiod("00:05:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:25:00-04:00")) expect_identical(nano_ceiling(as.nanotime("1922-10-10 12:23:23 America/New_York"), as.nanoperiod("00:05:00"), tz="America/New_York"), as.nanotime("1922-10-10T12:25:00-05:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("00:01:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:24:00-04:00")) expect_identical(nano_ceiling(as.nanotime("1922-10-10 12:25:00 America/New_York"), as.nanoperiod("00:05:00"), tz="America/New_York"), as.nanotime("1922-10-10T12:25:00-05:00")) ## seconds: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("00:00:05"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:25-04:00")) expect_identical(nano_ceiling(as.nanotime("1969-10-10 12:23:23 America/New_York"), as.nanoperiod("00:00:05"), tz="America/New_York"), as.nanotime("1969-10-10T12:23:25-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123 America/New_York"), as.nanoperiod("00:00:01"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:24-04:00")) expect_identical(nano_ceiling(as.nanotime("1888-10-10 12:23:23.123 America/New_York"), as.nanoperiod("00:00:11"), tz="America/New_York"), as.nanotime("1888-10-10T12:23:34-05:00")) ## milliseconds expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.001"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.124-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.010"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.13-04:00")) ## microseconds expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000001"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123457-04:00")) expect_identical(nano_ceiling(as.nanotime("1933-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000001"), tz="America/New_York"), as.nanotime("1933-10-10T12:23:23.123457-05:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000010"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.12346-04:00")) ## nanoseconds expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000001"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123456789-04:00")) expect_identical(nano_ceiling(as.nanotime("1931-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000001"), tz="America/New_York"), as.nanotime("1931-10-10T12:23:23.123456789-05:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000010"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123456790-04:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000033"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123456789-04:00")) ## nano_floor ## years: expect_identical(nano_floor(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), tz="America/New_York"), as.nanotime("2010-01-01T05:00:00-00:00")) expect_identical(nano_floor(as.nanotime("1970-01-01 06:00:00 America/New_York"), as.nanoperiod("12m"), tz="America/New_York"), as.nanotime("1970-01-01 America/New_York")) expect_error(nano_floor(c(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanotime("2010-10-10 11:00:00 America/New_York")), as.nanoperiod("12m"), tz="America/New_York"), "'x' must be sorted") expect_error(nano_floor(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), tz=c("America/New_York", "UTC")), "'tz' must be scalar") expect_identical(nano_floor(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), origin=as.nanotime("2010-10-10 00:00:01 America/New_York"), tz="America/New_York"), as.nanotime("2010-10-10T04:00:01+00:00")) expect_error(nano_floor(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), origin=as.nanotime("2004-10-10 00:00:01 America/New_York"), tz="America/New_York"), "when specifying 'origin', the first interval must contain at least one observation") expect_error(nano_floor(as.nanotime("2010-10-10 12:00:00 America/New_York"), as.nanoperiod("12m"), origin=as.nanotime(1:10), tz="America/New_York"), "'origin' must be scalar") expect_error(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoperiod("-12m"), tz="America/New_York"), "'precision' must be strictly positive") expect_error(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoperiod("-12m"), tz="America/New_York", origin="wrong type"), "'origin' must be of class 'nanotime'") expect_error(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoperiod("-12m"), tz=12), "'tz' must be of type 'character'") ## hours: expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("06:00:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:00:00-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("07:00:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:00:00-04:00")) ## minutes: expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("00:05:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:20:00-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:20:00 America/New_York"), as.nanoperiod("00:05:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:20:00-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("00:01:00"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:00-04:00")) expect_identical(nano_floor(as.nanotime("1911-10-10 12:20:00 America/New_York"), as.nanoperiod("00:01:00"), tz="America/New_York"), as.nanotime("1911-10-10T12:20:00-05:00")) ## seconds: expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 America/New_York"), as.nanoperiod("00:00:05"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:20-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123 America/New_York"), as.nanoperiod("00:00:01"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23-04:00")) ## milliseconds expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.001"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.010"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.12-04:00")) ## microseconds expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000001"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123456-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000010"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.12345-04:00")) ## nanoseconds expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000001"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123456789-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000010"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.12345678-04:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000033"), tz="America/New_York"), as.nanotime("2010-10-10T12:23:23.123456789-04:00")) expect_identical(nano_floor(as.nanotime("1965-10-10 12:23:23.123456789 America/New_York"), as.nanoperiod("00:00:00.000000033"), tz="America/New_York"), as.nanotime("1965-10-10T12:23:23.123456789-04:00")) ## rep expect_identical(rep(as.nanoperiod(1), 2), as.nanoperiod(rep(1,2))) expect_identical(rep(as.nanoperiod(1:2), each=2), as.nanoperiod(rep(1:2, each=2))) nanotime/inst/tinytest/test_data.frame.R0000644000176200001440000001014213713516331020111 0ustar liggesuserslibrary(nanotime) ## nanotime ##test_nanotime_data_frame_constructor <- function() { ## simpler data.frame, inserts 'formatted' set.seed(42) N <- 300 shine <- nanotime(Sys.time()) + cumsum(10*rpois(n=N+1, lambda=4)) rain <- nanotime(Sys.time()) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) newdf <- data.frame(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanotime_data_frame_rbind <- function() { t1 <- nanotime(1:10) d1 <- 1:10 t2 <- nanotime(11:20) d2 <- 11:20 df1 <- data.frame(t = t1, d = d1) df2 <- data.frame(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.frame(t = c(t1, t2), d = c(d1, d2))) ##test_nanotime_data_frame_cbind <- function() { t1 <- nanotime(1:10) d1 <- 1:10 t2 <- nanotime(11:20) d2 <- 11:20 df1 <- data.frame(t1 = t1, d1 = d1) df2 <- data.frame(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.frame(t1 = t1, d1 = d1, t2=t2, d2=d2)) ## nanoduration ##test_nanoduration_data_frame_constructor <- function() { ## simpler data.frame, inserts 'formatted' set.seed(42) N <- 300 shine <- as.nanoduration(1000) + cumsum(10*rpois(n=N+1, lambda=4)) rain <- as.nanoduration(2000) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) newdf <- data.frame(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanoduration_data_frame_rbind <- function() { t1 <- as.nanoduration(1:10) d1 <- 1:10 t2 <- as.nanoduration(11:20) d2 <- 11:20 df1 <- data.frame(t = t1, d = d1) df2 <- data.frame(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.frame(t = c(t1, t2), d = c(d1, d2))) ##test_nanoduration_data_frame_cbind <- function() { t1 <- as.nanoduration(1:10) d1 <- 1:10 t2 <- as.nanoduration(11:20) d2 <- 11:20 df1 <- data.frame(t1 = t1, d1 = d1) df2 <- data.frame(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.frame(t1 = t1, d1 = d1, t2=t2, d2=d2)) ## nanoperiod ##test_nanoperiod_data.frame_constructor <- function() { ## simpler data.frame, inserts 'formatted' set.seed(42) N <- 300 shine <- as.nanoperiod(1000) + cumsum(10*rpois(n=N+1, lambda=4)) rain <- as.nanoperiod(2000) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) newdf <- data.frame(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanoperiod_data_frame_rbind <- function() { t1 <- as.nanoperiod(1:10) d1 <- 1:10 t2 <- as.nanoperiod(11:20) d2 <- 11:20 df1 <- data.frame(t = t1, d = d1) df2 <- data.frame(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.frame(t = c(t1, t2), d = c(d1, d2))) ##test_nanoperiod_data_frame_cbind <- function() { t1 <- as.nanoperiod(1:10) d1 <- 1:10 t2 <- as.nanoperiod(11:20) d2 <- 11:20 df1 <- data.frame(t1 = t1, d1 = d1) df2 <- data.frame(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.frame(t1 = t1, d1 = d1, t2=t2, d2=d2)) ## nanoival ##test_nanoival_data.frame_constructor <- function() { ## simpler data.frame, inserts 'formatted' set.seed(42) N <- 300 shine_start <- nanotime(1000) + cumsum(10*rpois(n=N+1, lambda=4)) shine_end <- shine_start + as.nanoduration("01:00:00") rain_start <- nanotime(2000) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) rain_end <- shine_end + as.nanoduration("02:00:00") shine <- nanoival(shine_start, shine_end) rain <- nanoival(rain_start, rain_end) newdf <- data.frame(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanoival_data_frame_rbind <- function() { t1 <- nanoival(nanotime(1:10), nanotime(2:11)) d1 <- 1:10 t2 <- nanoival(nanotime(11:20), nanotime(12:21)) d2 <- 11:20 df1 <- data.frame(t = t1, d = d1) df2 <- data.frame(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.frame(t = c(t1, t2), d = c(d1, d2))) ##test_nanoival_data_frame_cbind <- function() { t1 <- nanoival(nanotime(1:10), nanotime(2:11)) d1 <- 1:10 t2 <- nanoival(nanotime(11:20), nanotime(12:21)) d2 <- 11:20 df1 <- data.frame(t1 = t1, d1 = d1) df2 <- data.frame(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.frame(t1 = t1, d1 = d1, t2=t2, d2=d2)) nanotime/inst/tinytest/test_ops.R0000644000176200001440000001073013745275661016730 0ustar liggesusers suppressMessages({ library(nanotime) library(bit64) }) ## ------------ `-` #"test_nanotime-nanotime" <- function() { expect_identical(nanotime(2) - nanotime(1), as.nanoduration(1)) expect_identical(nanotime(-1) - nanotime(-2), as.nanoduration(1)) #"test_nanotime-integer64" <- function() { expect_identical(nanotime(2) - as.integer64(1), nanotime(1)) expect_identical(nanotime(-1) - as.integer64(-2), nanotime(1)) #"test_nanotime-integer" <- function() { expect_identical(nanotime(2) - 1L, nanotime(1)) expect_identical(nanotime(-1) - -2L, nanotime(1)) #"test_nanotime-character" <- function() { expect_error(nanotime(0) - "A", "invalid operand types") #"test_character-nanotime" <- function() { expect_error("A" - nanotime(0), "invalid operand types") #"test_numeric-nanotime" <- function() { expect_error(1 - nanotime(0), "invalid operand types") ## ----------- `+` #"test_nanotime+numeric" <- function() { expect_identical(nanotime(0) + 1, nanotime(1)) expect_identical(nanotime(0) + -1, nanotime(-1)) #"test_nanotime+integer" <- function() { expect_identical(nanotime(0) + 1L, nanotime(1)) expect_identical(nanotime(0) + -1L, nanotime(-1)) #"test_nanotime+integer64" <- function() { expect_identical(nanotime(0) + as.integer64(1), nanotime(1)) expect_identical(nanotime(0) + as.integer64(-1), nanotime(-1)) #"test_nanotime+character" <- function() { expect_error(nanotime(0) + "A", "invalid operand types") #"test_character+nanotime" <- function() { expect_error("A" + nanotime(0), "invalid operand types") #"test_nanotime+nanotime" <- function() { expect_error(nanotime(1) + nanotime(0), "invalid operand types") #"test_nanotime+integer64" <- function() { expect_identical(nanotime(0) + as.integer64(1), nanotime(1)) expect_identical(nanotime(0) + as.integer64(-1), nanotime(-1)) #"test_numeric+nanotime" <- function() { expect_identical(nanotime(0) + 1, nanotime( 1)) expect_identical(nanotime(0) + -1, nanotime(-1)) #"test_integer+nanotime" <- function() { expect_identical( 1L + nanotime(0), nanotime(1)) expect_identical(-1L + nanotime(0), nanotime(-1)) ## ---------- other ops #test_compare_nanotime_ANY <- function() { expect_true(nanotime(1) == nanotime(1)) expect_true(nanotime(1) == as.integer64(1)) expect_true(nanotime(1) == 1L) expect_true(nanotime(1) == 1) expect_error(is.na(nanotime(1) == "a")) # now passes on and gets parse error expect_true(!(nanotime(1) < nanotime(1))) expect_true(!(nanotime(1) < as.integer64(1))) expect_true(!(nanotime(1) < 1L)) expect_true(!(nanotime(1) < 1)) #test_compare_ANY_nanotime <- function() { expect_true(as.integer64(1) == nanotime(1)) expect_true(1L == nanotime(1)) expect_true(1 == nanotime(1)) expect_true(!("a" == is.na(nanotime(1)))) expect_true(!(as.integer64(1) < nanotime(1))) expect_true(!(1L < nanotime(1))) expect_true(!(1 < nanotime(1))) #test_compare_character_nanotime <- function() { expect_true(isFALSE("2018-12-28T16:34:59.649943448+00:00" < nanotime("2018-12-28T16:34:59.000000000+00:00"))) expect_true("2018-12-28T16:34:59.649943448+00:00" > nanotime("2018-12-28T16:34:59.000000000+00:00")) expect_true("2018-12-28T16:34:59.649943448+00:00" == nanotime("2018-12-28T16:34:59.649943448+00:00")) #test_compare_nanotime_character <- function() { expect_true(isFALSE(nanotime("2018-12-28T16:34:59.649943448+00:00") < "2018-12-28T16:34:59.000000000+00:00")) expect_true(nanotime("2018-12-28T16:34:59.649943448+00:00") > "2018-12-28T16:34:59.000000000+00:00") expect_true(nanotime("2018-12-28T16:34:59.649943448+00:00") == "2018-12-28T16:34:59.649943448+00:00") #test_Logic <- function() { exc <- "operations are possible only for numeric, logical or complex types" #expect_error(nanotime(1) & nanotime(1), exc) expect_error(nanotime(1) & as.integer64(1), exc) expect_error(nanotime(1) & TRUE, exc) expect_error(as.integer64(1) & nanotime(1), exc) expect_error(1L & nanotime(1), exc) expect_error(FALSE & nanotime(1), exc) #test_Math <- function() { expect_error(abs(nanotime(1)), "non-numeric argument to mathematical function") #test_Math2 <- function() { expect_error(round(nanotime(1), 2), "non-numeric argument to mathematical function") #test_Summary <- function() { expect_error(sum(nanotime(1)))#, "invalid 'type' (nanotime) of argument") expect_identical(min(nanotime(c(1,8,4,2,0,3,10))), nanotime(0)) expect_identical(max(nanotime(c(1,8,4,2,0,3,10))), nanotime(10)) expect_identical(range(nanotime(c(1,8,4,2,0,3,10))), nanotime(c(0, 10))) #test_Complex <- function() { expect_error(Arg(nanotime(1)), "non-numeric argument to function") nanotime/inst/tinytest/test_nanoduration.R0000644000176200001440000007426614323545236020635 0ustar liggesusers suppressMessages({ library(nanotime) library(bit64) }) options(digits=7) # needed for error message below milli <- 1e6 sec <- 1e9 minute <- 60 * sec hour <- 60 * minute ## constructors ##test_nanoduration <- function() { expect_identical(nanoduration(1,1,1,1), as.nanoduration("01:01:01.000_000_001")) expect_identical(nanoduration(-1,0,0,1), as.nanoduration("-00:59:59.999_999_999")) ## R recycling: expect_identical(nanoduration(1:2,1,1,1), c(as.nanoduration("01:01:01.000_000_001"), as.nanoduration("02:01:01.000_000_001"))) expect_identical(nanoduration(), as.nanoduration(NULL)) expect_identical(length(nanoduration()), 0L) expect_identical(nanoduration(), as.nanoduration()) ##test_as.nanoduration_character_and_numeric <- function() { expect_identical(as.nanoduration("1:00:00"), as.nanoduration(hour)) expect_identical(as.nanoduration("-1:00:00"), -as.nanoduration(hour)) expect_identical(as.nanoduration("0:01:00"), as.nanoduration(minute)) expect_identical(as.nanoduration("0:00:01"), as.nanoduration(sec)) expect_identical(as.nanoduration("0:00:00.001"), as.nanoduration(milli)) expect_identical(c(as.nanoduration("1:00:00"), c(as.nanoduration("2:00:00"))), c(as.nanoduration(hour), as.nanoduration(2*hour))) expect_identical(as.nanoduration(NA_integer64_), as.nanoduration(as.integer64("-9223372036854775808"))) ## check name: n1 <- as.nanoduration(hour) names(n1) <- "a" expect_identical(as.nanoduration(c(a="1:00:00")), as.nanoduration(n1)) expect_error(as.nanoduration("10:aa"), "cannot parse nanoduration") expect_error(as.nanoduration("1000a"), "cannot parse nanoduration") expect_error(as.nanoduration("10:10:10.1000a"), "cannot parse nanoduration") expect_error(as.nanoduration("a"), "cannot parse nanoduration") expect_error(as.nanoduration(""), "cannot parse nanoduration") ##test_as.nanoduration_integer64 <- function() { expect_identical(as.nanoduration(as.integer64(hour)), as.nanoduration(hour)) expect_identical(as.nanoduration(c(a=as.integer64(hour), b=as.integer64(2*hour))), as.nanoduration(c(a=hour, b=2*hour))) ##test_as.nanoduration_integer <- function() { expect_identical(as.nanoduration(as.integer(sec)), as.nanoduration(sec)) expect_identical(as.nanoduration(c(a=as.integer(milli), b=as.integer(2*milli))), as.nanoduration(c(a=milli, b=2*milli))) ##test_as.integer64 <- function() { expect_identical(as.integer64(as.nanoduration(hour)), as.integer64(hour)) expect_identical(as.integer64(as.nanoduration(1:1000)), as.integer64(1:1000)) ## show/print/format ##test_show <- function() { d <- nanoduration(1,1,1,1) expect_identical(format(d), "01:01:01.000_000_001") expect_identical(format(-d), "-01:01:01.000_000_001") expect_true(is.na(format(as.nanoduration(as.integer64("-9223372036854775808"))))) expect_identical(as.character(d), "01:01:01.000_000_001") expect_identical(as.character(-d), "-01:01:01.000_000_001") expect_true(is.na(as.character(as.nanoduration(as.integer64("-9223372036854775808"))))) expect_stdout(show(d)) expect_stdout(show(-d)) expect_stdout(show(as.nanoduration(as.integer64("-9223372036854775808")))) ##test_print <- function() { d <- nanoduration(1,1,1,1) expect_stdout(print(d)) expect_stdout(print(nanoduration())) ##test_print_name <- function() { d <- nanoduration(1,1,1,1) names(d) <- "a" expect_identical(format(d), c(a="01:01:01.000_000_001")) expect_stdout(print(d)) ##test_format <- function() { d <- nanoduration(1,1,1,1) expect_identical(format(d), "01:01:01.000_000_001") ## subset: ##test_subset_int <- function() { dd <- as.nanoduration(1:10) expect_identical(dd[1:2], as.nanoduration(1:2)) expect_identical(dd[-1:-5], as.nanoduration(6:10)) expect_identical(dd[c(0,0,0,0,0,1,2,3,4,5)], as.nanoduration(1:5)) expect_warning(dd[1, 2], "unused indices or arguments in 'nanoduration' subsetting") ##test_subset_logical <- function() { dd <- as.nanoduration(1:4) expect_identical(dd[c(T,F,F,F)], dd[1]) expect_identical(dd[c(F,T,F,F)], dd[2]) expect_identical(dd[c(F,F,T,F)], dd[3]) expect_identical(dd[c(F,F,F,T)], dd[4]) expect_identical(dd[TRUE], dd) expect_identical(dd[c(F,T,T,F)], dd[2:3]) expect_warning(dd[T, F], "unused indices or arguments in 'nanoduration' subsetting") expect_identical(dd[c(F,F,F,NA)], NA_nanoduration_) ##test_subset_character <- function() { dd <- c(x=as.nanoduration(1), y=as.nanoduration(2)) expect_identical(dd["x"], c(x=as.nanoduration(1))) expect_identical(dd["y"], c(y=as.nanoduration(2))) expect_warning(dd["x", "y"], "unused indices or arguments in 'nanoduration' subsetting") ## also check out of bound subset res <- as.nanoduration(as.integer64(NA)) names(res) <- NA expect_identical(dd["a"], res) expect_warning(dd["a", "b"], "unused indices or arguments in 'nanoduration' subsetting") ## subset incorrect index type expect_error(dd[as.integer64(1)], "']' not defined on 'nanoduration' for index of type 'ANY'") ## subassign: ##test_subassign_logical <- function() { x <- as.nanoduration(1:10) x[c(T,T,T,F,F,F,F,F,F,F)] <- as.nanoduration(2:4) expect_identical(x, as.nanoduration(c(2:4, 4:10))) ##test_subassign_numeric <- function() { x <- as.nanoduration(1:10) x[1:3] <- as.nanoduration(2:4) x[4:10] <- as.nanoduration(5:11) expect_identical(x, as.nanoduration(2:11)) ##test_subsassign_character <- function() { dd <- c(a=as.nanoduration(1), b=as.nanoduration(2), c=as.nanoduration(3), d=as.nanoduration(4)) dd[c("b", "c")] <- as.nanoduration(20:21) expected <- c(a=as.nanoduration(1), b=as.nanoduration(20), c=as.nanoduration(21), d=as.nanoduration(4)) expect_identical(dd, expected) ##test_square_bracket <- function() { dd <- c(a=as.nanoduration(1), b=as.nanoduration(2), c=as.nanoduration(3), d=as.nanoduration(4)) dd_nonames <- as.nanoduration(1:4) expect_identical(dd_nonames[1], dd[[1]]) expect_identical(dd_nonames[2], dd[[2]]) expect_identical(dd_nonames[3], dd[[3]]) ## test names ##test_get_names <- function() { dd <- c(a=as.nanoduration(1), b=as.nanoduration(2), c=as.nanoduration(3), d=as.nanoduration(4)) expect_identical(names(dd), c("a","b","c","d")) ##test_set_names <- function() { names <- c("a","b","c","d") dd <- as.nanoduration(1:4) names(dd) <- names expect_identical(names(dd), names) names(dd)[1] <- "x" expect_identical(names(dd), c("x","b","c","d")) ## test scalar/vector mix LLL ## ops ## - ##test_nanoduration_minus_nanoduration <- function() { expect_identical(as.nanoduration("1:00:00") - as.nanoduration("00:01:00"), as.nanoduration("00:59:00")) expect_identical(as.nanoduration("-1:00:00") - as.nanoduration("00:01:00"), as.nanoduration("-01:01:00")) expect_identical(as.nanoduration("1:00:00.1") - as.nanoduration("1:00:00"), as.nanoduration("0.1")) expect_identical(as.nanoduration(1:10) - as.nanoduration(0:9), as.nanoduration(rep(1, 10))) expect_identical(as.nanoduration(1:10) - as.nanoduration(1), as.nanoduration(0:9)) expect_identical(c(a=as.nanoduration(1), b=as.nanoduration(1)) - as.nanoduration(1), as.nanoduration(c(a=0, b=0))) ##test_nanoduration_minus_numeric <- function() { expect_identical(as.nanoduration("1:00:00") - minute, as.nanoduration("00:59:00")) expect_identical(as.nanoduration(1:10) - 0.0:9, as.nanoduration(rep(1, 10))) expect_identical(as.nanoduration(1:10) - 1, as.nanoduration(0:9)) expect_identical(c(a=as.nanoduration(1), b=as.nanoduration(1)) - 1, as.nanoduration(c(a=0, b=0))) ##test_nanoduration_minus_integer <- function() { expect_identical(as.nanoduration("1:00:00") - as.integer(milli), as.nanoduration("00:59:59.999")) expect_identical(as.nanoduration(1:10) - 0:9, as.nanoduration(rep(1, 10))) expect_identical(as.nanoduration(1:10) - as.integer(1), as.nanoduration(0:9)) expect_identical(c(a=as.nanoduration(1), b=as.nanoduration(1)) - as.integer(1), as.nanoduration(c(a=0, b=0))) ##test_nanoduration_minus_integer64 <- function() { expect_identical(as.nanoduration("1:00:00") - as.integer64(minute), as.nanoduration("00:59:00")) expect_identical(as.nanoduration(1:10) - as.integer64(0:9), as.nanoduration(rep(1, 10))) expect_identical(as.nanoduration(1:10) - as.integer64(1), as.nanoduration(0:9)) expect_identical(c(a=as.nanoduration(1), b=as.nanoduration(1)) - c(c=as.integer64(1)), as.nanoduration(c(a=0, b=0))) ##test_integer64_minus_nanoduration <- function() { expect_identical(as.integer64(hour) - as.nanoduration("1:00:00"), as.nanoduration("0:00:00")) ##test_nanoduration_minus_integer64 <- function() { expect_identical(as.nanoduration("1:00:00") - as.integer64(hour), as.nanoduration("0:00:00")) ##test_numeric_minus_nanoduration <- function() { expect_identical(hour - as.nanoduration("1:00:00"), as.nanoduration("0:00:00")) ##test_integer_minus_nanoduration <- function() { expect_identical(as.integer(1e9) - as.nanoduration("1:00:00"), as.nanoduration("-00:59:59")) ## LLL name issue here due do to underlying issues with 'bit64' ## ##test_numeric_minus_nanoduration <- function() { ## expect_identical(2 - c(a=as.nanoduration(1), b=as.nanoduration(2)), ## c(a=as.nanoduration(1), b=as.nanoduration(0))) ## expect_identical(2 - c(a=as.integer64(1), b=as.integer64(2)), ## c(a=as.integer64(1), b=as.integer64(0))) ## ##test_any_minus_nanoduration <- function() { expect_error("a" - as.nanoduration("1:00:00"), "invalid operand types") ##test_nanoduration_minus_any <- function() { expect_error(as.nanoduration("1:00:00") - "a", "invalid operand types") ## + ##test_nanoduration_plus_nanoduration <- function() { expect_identical(as.nanoduration("1:00:00") + as.nanoduration("00:01:00"), as.nanoduration("01:01:00")) expect_identical(as.nanoduration("-1:00:00") + as.nanoduration("00:01:00"), as.nanoduration("-00:59:00")) expect_identical(as.nanoduration("-1:00:00.1") + as.nanoduration("1:00:00"), as.nanoduration("-0.1")) expect_identical(-as.nanoduration(1:10) + as.nanoduration(0:9), as.nanoduration(rep(-1, 10))) expect_identical(as.nanoduration(1:10) + as.nanoduration(1), as.nanoduration(2:11)) expect_identical(c(a=as.nanoduration(1), b=as.nanoduration(1)) + as.nanoduration(1), as.nanoduration(c(a=2, b=2))) ##test_integer64_plus_nanoduration <- function() { expect_identical(as.integer64(hour) + as.nanoduration("1:00:00"), as.nanoduration("2:00:00")) ##test_nanoduration_plus_integer64 <- function() { expect_identical(as.nanoduration("1:00:00") + as.integer64(hour), as.nanoduration("2:00:00")) ##test_nanoduration_plus_numeric <- function() { expect_identical(as.nanoduration("1:00:00") + hour, as.nanoduration("2:00:00")) ##test_numeric_plus_nanoduration <- function() { expect_identical(hour + as.nanoduration("1:00:00"), as.nanoduration("2:00:00")) ##test_character_plus_nanoduration <- function() { expect_error("hello" + as.nanoduration("1:00:00"), "invalid operand types") ##test_any_plus_nanoduration <- function() { expect_error("a" + as.nanoduration("1:00:00"), "invalid operand types") ##test_nanoduration_plus_any <- function() { expect_error(as.nanoduration("1:00:00") + "a", "invalid operand types") ## * ##test_nanoduration_times_numeric <- function() { expect_identical(as.nanoduration("00:01:00") * 3, as.nanoduration("00:03:00")) ##test_numeric_times_nanoduration <- function() { expect_identical(3 * as.nanoduration("00:01:00"), as.nanoduration("00:03:00")) ##test_nanoduration_times_integer64 <- function() { expect_identical(as.nanoduration("00:01:00") * as.integer64(3), as.nanoduration("00:03:00")) ##test_nanoduration_times_nanoduration <- function() { expect_error(as.nanoduration(1) * as.nanoduration(2), "invalid operand types") ## LLL have to fix this, dependent also on 'integer64' fixes... ## ##test_numeric_times_nanoduration <- function() { ## expect_identical(1.5 * as.nanoduration("00:01:00"), as.nanoduration("00:01:30")) ## ##test_numeric_times_nanoduration <- function() { expect_identical(3 * as.nanoduration("00:01:00"), as.nanoduration("00:03:00")) ##test_integer64_times_nanoduration <- function() { expect_identical(as.integer64(3) * as.nanoduration("00:01:00"), as.nanoduration("00:03:00")) ##test_any_times_nanoduration <- function() { expect_error("hello" * as.nanoduration("00:01:00"), "invalid operand types") ##test_nanoduration_times_character <- function() { expect_error(as.nanoduration("00:01:00") * "hello", "invalid operand types") ## / ##test_nanoduration_div_numeric <- function() { expect_identical(as.nanoduration("00:03:00") / 3, as.nanoduration("00:01:00")) ##test_nanoduration_div_integer64 <- function() { expect_identical(as.nanoduration("00:03:00") / as.integer64(3), as.nanoduration("00:01:00")) ##test_nanoduration_div_integer <- function() { expect_identical(as.nanoduration("00:03:00") / as.integer(3), as.nanoduration("00:01:00")) ##test_numeric_div_nanoduration <- function() { expect_error(1.5 / as.nanoduration("00:01:00"), "invalid operand types") ##test_nanoduration_div_any <- function() { expect_error(as.nanoduration("1:00:00") / "a", "invalid operand types") ##test_nanoduration_div_nanoduration <- function() { expect_identical(as.nanoduration(6) / as.nanoduration(2), as.integer64(3)) ## unary ##test_unary_minus <- function() { expect_identical(-as.nanoduration("00:01:00"), as.nanoduration("-00:01:00")) ##test_unary_plus <- function() { expect_identical(+as.nanoduration("00:01:00"), as.nanoduration("00:01:00")) ## Summary ##test_sum <- function() { ## error in underlying bit64: LLL ## expect_identical(sum(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3)), ## as.nanoduration(6)) expect_identical(sum(c(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3))), as.nanoduration(6)) ##test_min <- function() { ## error in underlying bit64: LLL ## expect_identical(min(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3)), ## as.nanoduration(1)) expect_identical(min(c(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3))), as.nanoduration(1)) ##test_max <- function() { ## error in underlying bit64: LLL ## expect_identical(max(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3)), ## as.nanoduration(3)) expect_identical(max(c(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3))), as.nanoduration(3)) ##test_range <- function() { ## error in underlying bit64: LLL ## expect_identical(range(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3)), ## c(as.nanoduration(1), as.nanoduration(3))) expect_identical(range(c(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3))), c(as.nanoduration(1), as.nanoduration(3))) ##test_prod <- function() { expect_error(prod(c(as.nanoduration(1), as.nanoduration(2), as.nanoduration(3))), "invalid 'type' \\(nanoduration\\) of argument") ## Complex ##test_Complex <- function() { expect_error(Arg(as.nanoduration(1)), "non-numeric argument to function") ## Logic ##test_Logic <- function() { expect_error(as.nanoduration(1) | as.nanoduration(1), "operations are possible only for numeric, logical or complex types") expect_error(as.nanoduration(1) | "a", "operations are possible only for numeric, logical or complex types") expect_error("a" & as.nanoduration(1), "operations are possible only for numeric, logical or complex types") ## Math ##test_abs <- function() { expect_identical(abs(as.nanoduration(-1)), as.nanoduration(1)) ##test_sign <- function() { expect_identical(sign(as.nanoduration(-1)), as.integer64(-1)) expect_identical(sign(as.nanoduration(1)), as.integer64(1)) ##test_Math <- function() { expect_error(sqrt(as.nanoduration(1)), "non-numeric argument to mathematical function") ## Math2 ##test_Math2 <- function() { expect_error(round(as.nanoduration(1)), "non-numeric argument to mathematical function") ## Compare ##test_Compare_nanoduration_ANY <- function() { expect_error(as.nanoduration(1) < "a", "cannot parse nanoduration") ## not quite clear in R: ## > 1 < list(1) ## [1] FALSE ## > 1 > list(1) ## [1] FALSE ## > 1 == list(1) ## [1] TRUE ##test_Compare_ANY_nanoduration <- function() { expect_error("a" < as.nanoduration(1), "cannot parse nanoduration") ##test_Compare_character_nanoduration <- function() { expect_true("12:13:14.151617" == as.nanoduration("12:13:14.151617")) expect_false("12:13:14.151617" == as.nanoduration("12:13:14.151617001")) expect_true("12:13:14.151617" != as.nanoduration("12:13:14.151617001")) expect_false("12:13:14.151617" != as.nanoduration("12:13:14.151617")) expect_true("12:13:14.151617" < as.nanoduration("12:13:14.151617001")) expect_false("12:13:14.151617001" < as.nanoduration("12:13:14.151617")) expect_true("12:13:14.151617" <= as.nanoduration("12:13:14.151617")) expect_false("12:13:14.151617001" <= as.nanoduration("12:13:14.151617")) expect_true("12:13:14.151617001" > as.nanoduration("12:13:14.151617")) expect_false("12:13:14.151617" > as.nanoduration("12:13:14.151617001")) expect_true("12:13:14.151617" >= as.nanoduration("12:13:14.151617")) expect_false("12:13:14.151617" >= as.nanoduration("12:13:14.151617001")) ##test_Compare_nanoduration_character <- function() { expect_true(as.nanoduration("12:13:14.151617") == "12:13:14.151617") expect_false(as.nanoduration("12:13:14.151617") == "12:13:14.151617001") expect_true(as.nanoduration("12:13:14.151617") != "12:13:14.151617001") expect_false(as.nanoduration("12:13:14.151617") != "12:13:14.151617") expect_true(as.nanoduration("12:13:14.151617") < "12:13:14.151617001") expect_false(as.nanoduration("12:13:14.151617001") < "12:13:14.151617") expect_true(as.nanoduration("12:13:14.151617") <= "12:13:14.151617") expect_false(as.nanoduration("12:13:14.151617001") <= "12:13:14.151617") expect_true(as.nanoduration("12:13:14.151617001") > "12:13:14.151617") expect_false(as.nanoduration("12:13:14.151617") > "12:13:14.151617001") expect_true(as.nanoduration("12:13:14.151617") >= "12:13:14.151617") expect_false(as.nanoduration("12:13:14.151617") >= "12:13:14.151617001") ## Arith ##test_Arith <- function() { expect_identical(as.nanoduration(4) %% 3, as.integer64(1)) ## NA stuff expect_true(is.na(as.nanoduration(as.integer(NA)))) expect_true(is.na(as.nanoduration(as.integer(NaN)))) d <- as.nanoduration(1:10) is.na(d) <- 1:3 expect_true(all(is.na(d[1:3]))) expect_true(!any(is.na(d[4:10]))) expect_true(is.na(NA_nanoduration_)) expect_identical(is.na(c(a=NA_nanoduration_)), c(a=TRUE)) ## test S4 conversions: expect_identical(nanoduration(1,1,1,1), as("01:01:01.000_000_001", "nanoduration")) expect_identical(as.nanoduration(as.integer64(hour)), as(hour, "nanoduration")) expect_identical(as.nanoduration(hour), as(hour, "nanoduration")) ## test seq: expect_identical(seq(as.nanoduration("00:00:00"), by=as.nanoduration("00:00:01"), length.out=10), as.nanoduration(seq(0, by=1e9, length.out=10))) expect_identical(seq(as.nanoduration("00:00:00"), to=as.nanoduration("00:00:09"), length.out=10), as.nanoduration(seq(0, by=1e9, length.out=10))) expect_identical(seq(as.nanoduration("00:00:00"), to=as.nanoduration("00:00:09"), along.with=1:10), as.nanoduration(seq(0, by=1e9, along.with=1:10))) ## all.equal ##test_all.equal_nanotime_any <- function() { expect_true(!isTRUE(all.equal(nanotime(1), "a"))) ##test_all.equal_any_nanotime <- function() { expect_true(!isTRUE(all.equal("a", nanotime(1)))) ## all.equal expect_true(isTRUE(all.equal(as.nanoduration(1), as.nanoduration(1)))) expect_true(!isTRUE(all.equal(as.nanoduration(1), as.nanoduration(2)))) expect_identical(all.equal(as.nanoduration(1), as.nanoduration(2)), "Mean relative difference: 1") expect_identical(all.equal(as.nanoduration(c(1L,NA)), as.nanoduration(1:2)), "'is.NA' value mismatch: 0 in current 1 in target") expect_error(all.equal(as.nanoduration(1), as.nanoduration(1), tolerance="1"), "'tolerance' should be numeric") expect_error(all.equal(as.nanoduration(1), as.nanoduration(1), scale="a"), "'scale' should be numeric or NULL") expect_error(all.equal(as.nanoduration(1), as.nanoduration(1), check.attributes="a"), "'check.attributes' must be logical") expect_error(all.equal(as.nanoduration(1), as.nanoduration(2), scale=-1), "all\\(scale > 0\\) is not TRUE") expect_false(isTRUE(all.equal(as.nanoduration(1), as.nanoperiod("1d")))) expect_identical(all.equal(as.nanoduration(1), as.nanoduration(1:2)), "Numeric: lengths (1, 2) differ") expect_identical(all.equal(as.nanoduration(c(1,2,3)), as.nanoduration(c(1,1,2)), countEQ=TRUE), "Mean relative difference: 0.3333333") expect_false(isTRUE(all.equal(as.nanoduration(1), 1i))) expect_identical(all.equal(as.nanoduration(1), as.nanoduration(3), tolerance=1), "Mean absolute difference: 2") expect_identical(all.equal(as.nanoduration(1), as.nanoduration(2e9), scale=1e9), "Mean scaled difference: 2") expect_identical(all.equal(as.nanoduration(1), as.nanoduration(2e9), scale=1), "Mean absolute difference: 2e+09") ## test rounding functions: ## nano_ceiling: ## hours: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 UTC"), as.nanoduration("06:00:00")), as.nanotime("2010-10-10T12:00:00+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:00:00 UTC"), as.nanoduration("01:00:00")), as.nanotime("2010-10-10T12:00:00+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("06:00:00")), as.nanotime("2010-10-10T18:00:00+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("07:00:00")), as.nanotime("2010-10-10T19:00:00+00:00")) expect_identical(nano_floor(as.nanotime("1940-12-12 00:12:23 UTC"), as.nanoduration("01:00:00")), as.nanotime("1940-12-12T00:00:00+00:00")) expect_identical(nano_ceiling(as.nanotime("1970-01-01 UTC"), as.nanoduration("06:00:00")), as.nanotime("1970-01-01T00:00:00+00:00")) expect_identical(nano_ceiling(as.nanotime("1970-01-01 UTC"), as.nanoduration("01:30:00")), as.nanotime("1970-01-01T00:00:00+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("07:00:00"), origin = as.nanotime("2010-10-10 10:23:12 UTC")), as.nanotime("2010-10-10T17:23:12+00:00")) expect_error(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("07:00:00"), origin = as.nanotime(1:10)), "'origin' must be scalar") expect_error(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("-06:00:00")), "'precision' must be strictly positive") expect_error(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("-06:00:00"), origin="wrong type"), "'origin' must be of class 'nanotime'") ## minutes: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("00:05:00")), as.nanotime("2010-10-10T12:25:00+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("00:01:00")), as.nanotime("2010-10-10T12:24:00+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("00:07:00"), origin = as.nanotime("2010-10-10 12:22:12 UTC")), as.nanotime("2010-10-10T12:29:12+00:00")) ## seconds: expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("00:00:05")), as.nanotime("2010-10-10T12:23:25+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123 UTC"), as.nanoduration("00:00:01")), as.nanotime("2010-10-10T12:23:24+00:00")) ## milliseconds expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.001")), as.nanotime("2010-10-10T12:23:23.124+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.010")), as.nanotime("2010-10-10T12:23:23.13+00:00")) ## microseconds expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000001")), as.nanotime("2010-10-10T12:23:23.123457+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000010")), as.nanotime("2010-10-10T12:23:23.12346+00:00")) ## nanoseconds expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000000001")), as.nanotime("2010-10-10T12:23:23.123456789+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000000010")), as.nanotime("2010-10-10T12:23:23.123456790+00:00")) expect_identical(nano_ceiling(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000000033")), as.nanotime("2010-10-10T12:23:23.123456814+00:00")) ## nano_floor ## hours: expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("06:00:00")), as.nanotime("2010-10-10T12:00:00+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("07:00:00")), as.nanotime("2010-10-10T12:00:00+00:00")) expect_identical(nano_floor(as.nanotime("1970-01-01 UTC"), as.nanoduration("06:00:00")), as.nanotime("1970-01-01T00:00:00+00:00")) expect_identical(nano_floor(as.nanotime("1970-01-01 UTC"), as.nanoduration("01:30:00")), as.nanotime("1970-01-01T00:00:00+00:00")) expect_identical(nano_floor(as.nanotime("1970-01-01 06:00:00 UTC"), as.nanoduration("06:00:00")), as.nanotime("1970-01-01T06:00:00+00:00")) expect_identical(nano_floor(as.nanotime("1970-01-01 07:00:00 UTC"), as.nanoduration("07:00:00")), as.nanotime("1970-01-01T07:00:00+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("07:00:00"), origin = as.nanotime("2010-10-10 10:23:12 UTC")), as.nanotime("2010-10-10T10:23:12+00:00")) expect_error(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("07:00:00"), origin = as.nanotime(1:10)), "'origin' must be scalar") expect_error(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("-06:00:00")), "'precision' must be strictly positive") expect_error(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("-06:00:00"), origin="wrong type"), "'origin' must be of class 'nanotime'") ## minutes: expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("00:05:00")), as.nanotime("2010-10-10T12:20:00+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("00:01:00")), as.nanotime("2010-10-10T12:23:00+00:00")) ## seconds: expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23 UTC"), as.nanoduration("00:00:05")), as.nanotime("2010-10-10T12:23:20+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123 UTC"), as.nanoduration("00:00:01")), as.nanotime("2010-10-10T12:23:23+00:00")) ## milliseconds expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.001")), as.nanotime("2010-10-10T12:23:23.123+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.010")), as.nanotime("2010-10-10T12:23:23.12+00:00")) ## microseconds expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000001")), as.nanotime("2010-10-10T12:23:23.123456+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000010")), as.nanotime("2010-10-10T12:23:23.12345+00:00")) ## nanoseconds expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000000001")), as.nanotime("2010-10-10T12:23:23.123456789+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000000010")), as.nanotime("2010-10-10T12:23:23.12345678+00:00")) expect_identical(nano_floor(as.nanotime("2010-10-10 12:23:23.123456789 UTC"), as.nanoduration("00:00:00.000000033")), as.nanotime("2010-10-10T12:23:23.123456781+00:00")) ## rep expect_identical(rep(as.nanoduration(1), 2), as.nanoduration(rep(1,2))) expect_identical(rep(as.nanoduration(1:2), each=2), as.nanoduration(rep(1:2, each=2))) ## difftime expect_identical(as.nanoduration(as.difftime(2, units = "secs")), nanoduration(seconds = 2)) expect_identical(as.nanoduration(as.difftime(2.5, units = "secs")), nanoduration(seconds = 2, nanoseconds = 5e8)) expect_identical(as.nanoduration(as.difftime(2, units = "hours")), nanoduration(hours = 2)) dt_1sec <- as.difftime(1, units = "secs") nd_1sec <- nanoduration(seconds = 1L) expect_identical(dt_1sec + nd_1sec, nanoduration(seconds = 2L)) expect_identical(nd_1sec + dt_1sec, nanoduration(seconds = 2L)) expect_identical(dt_1sec - nd_1sec, nanoduration(seconds = 0L)) expect_identical(nd_1sec - dt_1sec, nanoduration(seconds = 0L)) nt <- as.nanotime("2010-10-10 12:23:23.123456789 UTC") expect_identical(nt + dt_1sec, as.nanotime("2010-10-10 12:23:24.123456789 UTC")) expect_identical(dt_1sec + nt, as.nanotime("2010-10-10 12:23:24.123456789 UTC")) expect_identical(nt - dt_1sec, as.nanotime("2010-10-10 12:23:22.123456789 UTC")) expect_identical(nd_1sec + nt, as.nanotime("2010-10-10 12:23:24.123456789 UTC")) savedFormat <- options()$nanotimeFormat options(nanotimeFormat="%Y-%m-%d %H:%M:%S") ni <- as.nanoival("+2013-01-04 15:00:00 -> 2013-01-04 17:00:00-") expect_identical(ni + dt_1sec, as.nanoival("+2013-01-04 15:00:01 -> 2013-01-04 17:00:01-")) expect_identical(dt_1sec + ni, as.nanoival("+2013-01-04 15:00:01 -> 2013-01-04 17:00:01-")) expect_identical(nd_1sec + ni, as.nanoival("+2013-01-04 15:00:01 -> 2013-01-04 17:00:01-")) expect_identical(ni - dt_1sec, as.nanoival("+2013-01-04 14:59:59 -> 2013-01-04 16:59:59-")) expect_identical(ni - nd_1sec, as.nanoival("+2013-01-04 14:59:59 -> 2013-01-04 16:59:59-")) options(nanotimeFormat=savedFormat) nanotime/inst/tinytest/test_nanoival.R0000644000176200001440000016045114131560240017720 0ustar liggesuserslibrary(nanotime) suppressMessages(library(bit64)) isSolaris <- Sys.info()[["sysname"]] == "SunOS" savedFormat <- NULL one_second <- 1e9 aa <- "+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-" bb <- "+2014-01-01 00:00:00 -> 2015-01-01 00:00:00+" cc <- "-2015-01-01 00:00:00 -> 2016-01-01 00:00:00-" dd <- "-2016-01-01 00:00:00 -> 2017-01-01 00:00:00+" savedFormat <- options()$nanotimeFormat options(nanotimeFormat="%Y-%m-%d %H:%M:%S") ## nanotime constructors/accessors ##test_as.nanoival <- function() { ni <- as.nanoival(aa) expect_identical(nanoival.start(ni), nanotime("2013-01-01 00:00:00")) & expect_identical(nanoival.end(ni), nanotime("2014-01-01 00:00:00")) & expect_identical(nanoival.sopen(ni), FALSE) & expect_identical(nanoival.eopen(ni), TRUE) ##test_as.nanoival_vector <- function() { ni <- as.nanoival(c(a=aa, b=bb, c=cc, d=dd)) expect_identical(nanoival.start(ni), c(a=nanotime("2013-01-01 00:00:00"), b=nanotime("2014-01-01 00:00:00"), c=nanotime("2015-01-01 00:00:00"), d=nanotime("2016-01-01 00:00:00"))) & expect_identical(nanoival.end(ni), c(a=nanotime("2014-01-01 00:00:00"), b=nanotime("2015-01-01 00:00:00"), c=nanotime("2016-01-01 00:00:00"), d=nanotime("2017-01-01 00:00:00"))) & expect_identical(nanoival.sopen(ni), c(a=FALSE, b=FALSE, c=TRUE, d=TRUE)) & expect_identical(nanoival.eopen(ni), c(a=TRUE, b=FALSE, c=TRUE, d=FALSE)) if (!isSolaris) { expect_identical(length(as.nanoival(vector("character", 0))), 0L) expect_identical(as.nanoival("-2013-01-01 00:00:00 America/New_York -> 2014-01-01 00:00:00 America/New_York+"), nanoival(nanotime("2013-01-01 00:00:00 America/New_York"), nanotime("2014-01-01 00:00:00 America/New_York"), TRUE, FALSE)) ## test warning when we double specify the timezone: expect_error(as.nanoival("-2013-01-01 00:00:00 America/New_York -> 2014-01-01 00:00:00+00:00+", tz="Europe/London"), "timezone is specified twice: in the string and as an argument") ##test_as.nanoival_vector_fail <- function() { expect_error(as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00"), "`nanoival` must end with '\\+' or '-'") expect_error(as.nanoival("2013-01-01 00:00:00 -> 2014-01-01 00:00:00-"), "`nanoival` must start with '\\+' or '-'") expect_error(as.nanoival("+2013-01-01 00:00:00 $$ 2014-01-01 00:00:00-"), "Parse error on 2013-01-01 00:00:00 \\$\\$ 2014-01-01 00:00:00") expect_error(as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00- "), "`nanoival` must end with '\\+' or '-'") expect_error(as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00a"), "`nanoival` must end with '\\+' or '-'") expect_error(as.nanoival("+2013-01-01 00:00:00 America/New_York -> 2014-01-01 00:00:00 America/New_York %%"), "`nanoival` must end with '\\+' or '-'") expect_error(as.nanoival("+2013-01-01 00:00:00 America/New_York -> 2014-01-01 00:00:00 America/New_York + "), "`nanoival` must end with '\\+' or '-'") expect_error(as.nanoival("-2013-01-01 00:00:00 America/New_York -> 2014-01-01 00:00:00 America/New_YYork+"), "Cannot retrieve timezone") } expect_error(as.nanoival(aa, tz=list(1)), "argument 'tz' must be of type 'character'") ##test_nanoival <- function() { expect_identical(nanoival(nanotime("2013-01-01 00:00:00"), nanotime("2014-01-01 00:00:00"), TRUE, TRUE), as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-")) expect_error(nanoival(nanotime(2), nanotime(1)), "interval end \\(1\\) smaller than interval start \\(2\\)") expect_identical(nanoival(), as.nanoival(NULL)) expect_identical(length(nanoival()), 0L) expect_identical(nanoival(), as.nanoival()) expect_identical(length(as.nanoival()), 0L) ##test_nanoival_vector<- function() { starts <- c(nanotime("2013-01-01 00:00:00"), nanotime("2014-01-01 00:00:00"), nanotime("2015-01-01 00:00:00"), nanotime("2016-01-01 00:00:00")) ends <- c(nanotime("2014-01-01 00:00:00"), nanotime("2015-01-01 00:00:00"), nanotime("2016-01-01 00:00:00"), nanotime("2017-01-01 00:00:00")) sopens <- c(FALSE, FALSE, TRUE, TRUE) eopens <- c(TRUE, FALSE, TRUE, FALSE) expect_identical(nanoival(starts, ends, sopens, eopens), as.nanoival(c(aa, bb, cc, dd))) ## different vector lengths: starts <- nanotime(1:3) ends <- nanotime(4) sopens <- c(TRUE, TRUE, TRUE) eopens <- c(FALSE, FALSE, FALSE) expect_identical(nanoival(starts, ends, sopens, eopens), c(nanoival(nanotime(1), nanotime(4), TRUE, FALSE), nanoival(nanotime(2), nanotime(4), TRUE, FALSE), nanoival(nanotime(3), nanotime(4), TRUE, FALSE))) expect_identical(nanoival(starts, ends, sopens[1], eopens), c(nanoival(nanotime(1), nanotime(4), TRUE, FALSE), nanoival(nanotime(2), nanotime(4), TRUE, FALSE), nanoival(nanotime(3), nanotime(4), TRUE, FALSE))) expect_identical(nanoival(starts[1], ends, sopens, eopens[1]), c(nanoival(nanotime(1), nanotime(4), TRUE, FALSE), nanoival(nanotime(1), nanotime(4), TRUE, FALSE), nanoival(nanotime(1), nanotime(4), TRUE, FALSE))) ## show/print/format ##test_show <- function() { ival_str <- "+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-" ival <- as.nanoival(ival_str) expect_identical(format(ival), ival_str) expect_stdout(show(ival)) ival_str <- "-2013-01-01 00:00:00 -> 2014-01-01 00:00:00+" ival <- as.nanoival(ival_str) expect_identical(format(ival), ival_str) expect_stdout(show(ival)) ival_str <- c(a="+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") ival <- as.nanoival(ival_str) expect_identical(format(ival), ival_str) expect_stdout(show(ival)) expect_identical(format(as.nanoival(vector("character", 0))), "nanoival(0)") ##test_format <- function() { ival_str <- "+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-" ival <- as.nanoival(ival_str) expect_identical(format(ival), ival_str) expect_identical(as.character(ival), ival_str) ival_str <- "-2013-01-01 00:00:00 -> 2014-01-01 00:00:00+" ival <- as.nanoival(ival_str) expect_identical(format(ival), ival_str) expect_identical(as.character(ival), ival_str) ## as.data.frame ##test_as.data.frame <- function() { ni <- as.nanoival(c(aa, bb, cc, dd)) expect_identical(as.data.frame(ni), data.frame(ni=ni)) rownames <- c("aa","bb","cc","dd") names(ni) <- rownames as.data.frame(ni) expect_identical(as.data.frame(ni), data.frame(ni=ni, row.names=rownames)) ## equality and comparison operators ## eq/ne ##test_eq <- function() { x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_true(x==x) y <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_true(!(x==y)) z <- as.nanoival("+2013-01-01 00:00:01 -> 2014-01-01 00:00:00-") expect_true(!(x==z)) ##test_ne <- function() { x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_true(!(x!=x)) y <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_true(x!=y) z <- as.nanoival("+2013-01-01 00:00:01 -> 2014-01-01 00:00:00-") expect_true(x!=z) ## lt ##test_lt_non_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival(c(b="+2015-01-01 00:00:00 -> 2016-01-01 00:00:00-")) expect_identical(x < y, c(b=TRUE)) expect_identical(y < x, c(b=FALSE)) ##test_lt_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(x < y, TRUE) expect_identical(y < x, FALSE) ##test_lt_same_end <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x < y, TRUE) expect_identical(y < x, FALSE) ##test_lt_included <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2013-07-01 00:00:00-") expect_identical(x < y, TRUE) expect_identical(y < x, FALSE) ##test_lt_same_start<- function() { ## x: c----------o ## y: c--------------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(x < y, TRUE) expect_identical(y < x, FALSE) ##test_lt_same_open_start <- function() { ## x: c----------o ## y: o----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x < y, TRUE) expect_identical(y < x, FALSE) ##test_lt_same_open_end <- function() { ## x: c----------o ## y: c----------c x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00+") expect_identical(x < y, TRUE) expect_identical(y < x, FALSE) ##test_lt_same <- function() { ## x: c----------o ## y: c----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x < y, FALSE) expect_identical(y < x, FALSE) ##test_lt_same <- function() { ## x: c----------o ## y: c----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x < y, FALSE) expect_identical(y < x, FALSE) ##test_lt_multiple <- function() { ## x: c----------o ## y: c----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2014-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(c(x, y) < c(y, x), c(TRUE, FALSE)) ## le ##test_le_non_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2015-01-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(x <= y, TRUE) expect_identical(y <= x, FALSE) ##test_le_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(x <= y, TRUE) expect_identical(y <= x, FALSE) ##test_le_same_end <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x <= y, TRUE) expect_identical(y <= x, FALSE) ##test_le_included <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2013-07-01 00:00:00-") expect_identical(x <= y, TRUE) expect_identical(y <= x, FALSE) ##test_le_same_start<- function() { ## x: c----------o ## y: c--------------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(x <= y, TRUE) expect_identical(y <= x, FALSE) ##test_le_same_open_start <- function() { ## x: c----------o ## y: o----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x <= y, TRUE) expect_identical(y <= x, FALSE) ##test_le_same_open_end <- function() { ## x: c----------o ## y: c----------c x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00+") expect_identical(x <= y, TRUE) expect_identical(y <= x, FALSE) ##test_le_same <- function() { ## x: c----------o ## y: c----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x <= y, TRUE) expect_identical(y <= x, TRUE) ## gt ##test_gt_non_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2015-01-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(x > y, FALSE) expect_identical(y > x, TRUE) ##test_gt_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(x > y, FALSE) expect_identical(y > x, TRUE) ##test_gt_same_end <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x > y, FALSE) expect_identical(y > x, TRUE) ##test_gt_included <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2013-07-01 00:00:00-") expect_identical(x > y, FALSE) expect_identical(y > x, TRUE) ##test_gt_same_start<- function() { ## x: c----------o ## y: c--------------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(x > y, FALSE) expect_identical(y > x, TRUE) ##test_gt_same_open_start <- function() { ## x: c----------o ## y: o----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x > y, FALSE) expect_identical(y > x, TRUE) ##test_gt_same_open_end <- function() { ## x: c----------o ## y: c----------c x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00+") expect_identical(x > y, FALSE) expect_identical(y > x, TRUE) ##test_gt_same <- function() { ## x: c----------c ## y: c----------c x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00+") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00+") expect_identical(x > y, FALSE) expect_identical(y > x, FALSE) ## ge ##test_ge_non_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2015-01-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(x >= y, FALSE) expect_identical(y >= x, TRUE) ##test_ge_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(x >= y, FALSE) expect_identical(y >= x, TRUE) ##test_ge_same_end <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x >= y, FALSE) expect_identical(y >= x, TRUE) ##test_ge_included <- function() { ## x: c----------o ## y: c----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-06-01 00:00:00 -> 2013-07-01 00:00:00-") expect_identical(x >= y, FALSE) expect_identical(y >= x, TRUE) ##test_ge_same_start<- function() { ## x: c----------o ## y: c--------------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(x >= y, FALSE) expect_identical(y >= x, TRUE) ##test_ge_same_open_start <- function() { ## x: c----------o ## y: o----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x >= y, FALSE) expect_identical(y >= x, TRUE) ##test_ge_same_open_end <- function() { ## x: c----------o ## y: c----------c x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00+") expect_identical(x >= y, FALSE) expect_identical(y >= x, TRUE) ##test_ge_same <- function() { ## x: o----------o ## y: o----------o x <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("-2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") expect_identical(x >= y, TRUE) expect_identical(y >= x, TRUE) ## sorting/ordering ##test_is_unsorted_non_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2015-01-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(is.unsorted(c(x, y)), FALSE) expect_identical(is.unsorted(c(y, x)), TRUE) ##test_is_unsorted_overlapping <- function() { ## x: c----------o ## y: c--------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") y <- as.nanoival("+2014-01-01 00:00:00 -> 2016-01-01 00:00:00-") expect_identical(is.unsorted(c(x, y)), FALSE) expect_identical(is.unsorted(c(y, x)), TRUE) ##test_is_unsorted_same_end <- function() { ## x: c----------o ## y: c-----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") y <- as.nanoival("+2014-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(is.unsorted(c(x, y)), FALSE) expect_identical(is.unsorted(c(y, x)), TRUE) ##test_is_unsorted_included <- function() { ## x: c----------o ## y: c-----o x <- as.nanoival("+2013-01-01 00:00:00 -> 2016-01-01 00:00:00-") y <- as.nanoival("+2014-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(is.unsorted(c(x, y)), FALSE) expect_identical(is.unsorted(c(y, x)), TRUE) ##test_is_unsorted_same_start <- function() { ## x: c----o ## y: c----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(is.unsorted(c(x, y)), FALSE) expect_identical(is.unsorted(c(y, x)), TRUE) ##test_is_unsorted_not_strictly <- function() { ## x: c----o ## y: c----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(is.unsorted(c(x, x, y, y)), FALSE) expect_identical(is.unsorted(c(y, y, x, x)), TRUE) ##test_is_unsorted_strictly <- function() { ## x: c----o ## y: c----------o x <- as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-") y <- as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-") expect_identical(is.unsorted(c(x, x, y, y), strictly=TRUE), TRUE) expect_identical(is.unsorted(c(y, y, x, x), strictly=TRUE), TRUE) expect_error(is.unsorted(c(y, y, x, x), strictly="a"), "argument 'strictly' must be a logical") expect_error(is.unsorted(c(y, y, x, x), strictly=as.logical(NULL)), "argument 'strictly' cannot have length 0") ## test 'na.rm': expect_identical(is.unsorted(c(x, y, NA_nanoival_)), NA_nanoival_) expect_identical(is.unsorted(c(x, y, NA_nanoival_), na.rm=TRUE), FALSE) ##test_sort <- function() { v <- as.nanoival(c(aa, bb, cc, dd)) v_descending <- as.nanoival(c(dd, cc, bb, aa)) expect_identical(sort(v_descending), v) expect_identical(sort(v, decreasing=TRUE), v_descending) expect_error(sort(v, decreasing=as.logical(NULL)), "argument 'decreasing' cannot have length 0") expect_error(sort(v, decreasing="not a logical"), "argument 'decreasing' must be logical") ## c ##test_c <- function() { # LLL a <- c(nanotime(1), nanotime(2)) expect_identical(a, nanotime(1:2)) a <- c(nanotime(1:2), nanotime(3:4)) expect_identical(a, nanotime(1:4)) ##test_c_name <- function() { c_xy <- c(x=as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-"), y=as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-")) expect_identical(names(c_xy), c("x","y")) ##test_c_name_assign <- function() { c_xy <- c(x=as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-"), y=as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-")) names(c_xy) <- c("a","b") expect_identical(names(c_xy), c("a","b")) ##test_c_name_assign_null <- function() { c_xy <- c(x=as.nanoival("+2013-01-01 00:00:00 -> 2014-01-01 00:00:00-"), y=as.nanoival("+2013-01-01 00:00:00 -> 2015-01-01 00:00:00-")) names(c_xy) <- NULL expect_true(is.null(names(c_xy))) ## set operations ## naming convention for interval tests: ## cc : start closed, end closed ## co : start closed, end open ## oc : etc. ## oo ## intersection ## -------------------------------------------------------------------------- ## time - interval ## test_intersect_time_interval_null_interval <- function() { i1 <- as.nanoival(NULL) s1 <- seq(nanotime("2015-01-01 12:00:00"), length.out=10, by=one_second) expect_identical(s1[i1], as.nanotime()) expect_identical(s1 %in% i1, rep(FALSE, 10)) ##test_intersect.idx_unsorted <- function() { a <- c(nanotime("2013-12-12 12:12:12"), nanotime("2012-12-12 12:12:12")) idx <- as.nanoival("+2012-12-12 12:12:14 -> 2012-12-12 12:12:19+") expect_error(intersect.idx(a, idx), "x must be sorted") expect_error(a %in% idx, "x must be sorted") ##test_subset_unsorted <- function() { a <- c(nanotime("2013-12-12 12:12:12"), nanotime("2012-12-12 12:12:12")) idx <- as.nanoival("+2012-12-12 12:12:14 -> 2012-12-12 12:12:19+") expect_error(a[idx], "x must be sorted") expect_error(a %in% idx, "x must be sorted") ## test that nanotime %in% nanotime still works as it goes through the same S3 a <- nanotime(3:6) idx <- nanotime(1:10) expect_identical(a %in% idx, 3:6 %in% 1:10) ## time - interval ## 1: .............. ## 2: c----c ## r: ...... ##test_intersect_idx_time_interval_cc <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- as.nanoival("+2012-12-12 12:12:14 -> 2012-12-12 12:12:19+") r <- list(x=c(3,4,5,6,7,8), y=c(1,1,1,1,1,1)) expect_identical(intersect.idx(a, idx), r) expect_identical(a %in% idx, 1:10 %in% c(3,4,5,6,7,8)) ## 1: .............. ## 2: c----c ## r: ...... ##test_intersect_time_interval_cc <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- as.nanoival("+2012-12-12 12:12:14 -> 2012-12-12 12:12:19+") r <- seq(nanotime("2012-12-12 12:12:14"), nanotime("2012-12-12 12:12:19"), by=one_second) expect_identical(a[idx], r) expect_identical(intersect(a, idx), r) ## 1: .............. ## 2: o----o ## r: .... ##test_intersect_time_interval_oo <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- as.nanoival("-2012-12-12 12:12:14 -> 2012-12-12 12:12:19-") r <- seq(nanotime("2012-12-12 12:12:15"), nanotime("2012-12-12 12:12:18"), by=one_second) expect_identical(a[idx], r) ## 1: ...... ## 2: o---------o ## r: ...... ##test_intersect_time_interval_overlapping <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- as.nanoival("-2012-12-12 12:12:10 -> 2012-12-12 12:12:30-") expect_identical(a[idx], a) ## 1: ................. ## 2: o-----o c-----c ## r: ..... ....... ##test_intersect_time_interval_multiple <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- c(as.nanoival("-2012-12-12 12:12:10 -> 2012-12-12 12:12:14-"), as.nanoival("+2012-12-12 12:12:18 -> 2012-12-12 12:12:20+")) r <- c(seq(nanotime("2012-12-12 12:12:12"), nanotime("2012-12-12 12:12:13"), by=one_second), seq(nanotime("2012-12-12 12:12:18"), nanotime("2012-12-12 12:12:20"), by=one_second)) expect_identical(a[idx], r) ##test_intersect_time_interval_multiple_direct_call <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- c(as.nanoival("-2012-12-12 12:12:10 -> 2012-12-12 12:12:14-"), as.nanoival("+2012-12-12 12:12:18 -> 2012-12-12 12:12:20+")) r <- c(seq(nanotime("2012-12-12 12:12:12"), nanotime("2012-12-12 12:12:13"), by=one_second), seq(nanotime("2012-12-12 12:12:18"), nanotime("2012-12-12 12:12:20"), by=one_second)) expect_identical(intersect(a, idx), r) ## interval - interval: ## 1: c-----------c ## 2: c-----------c ## r: c-----------c ##test_intersect_interval_interval_cc_cc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- i2 expect_true(intersect(i1, i2) == r) ## 1: c-----------c ## 2: o-----------c ## r: o-----------c ##test_intersect_interval_interval_cc_oc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- i2 expect_true(intersect(i1, i2) == r & intersect(i2, i1) == r) ## 1: c-----------c ## 2: c-----------o ## r: c-----------o ##test_intersect_interval_interval_cc_co__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- i2 expect_true(intersect(i1, i2) == r & intersect(i2, i1) == r) ## 1: c-----------o ## 2: o-----------c ## r: o-----------o ##test_intersect_interval_interval_co_oc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") expect_true(intersect(i1, i2) == r & intersect(i2, i1) == r) ## 1: o-----------o ## 2: o-----------o ## r: o-----------o ##test_intersect_interval_interval_oo_oo__2_eq_1 <- function() { i1 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- i2 expect_true(intersect(i1, i2) == r) ## 1: c-----------c ## 2: o-----------o ## r: o-----------o ##test_intersect_interval_interval_cc_oo__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- i2 expect_true(intersect(i1, i2) == r) ## 1: c-----------o ## 2: o-----------c ## r: ##test_intersect_interval_interval_co_oc__2_lg_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") r <- new("nanoival", as.complex(NULL)) expect_identical(intersect(i2, i1), r) ## 1: c-----------o ## 2: c-----------c ## r: ##test_intersect_interval_interval_co_cc__2_lg_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") r <- as.nanoival(NULL) expect_identical(intersect(i2, i1), r) ## 1: c-----------c ## 2: o-----------c ## r: ##test_intersect_interval_interval_cc_oc__2_lg_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") r <- as.nanoival(NULL) expect_identical(intersect(i2, i1), r) ## 1: c-----------c ## 2: c-----------c ## r: cc ##test_intersect_interval_interval_cc_cc__2_lg_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") r <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:05+") expect_identical(intersect(i2, i1), r) expect_identical(intersect(i1, i2), r) ## 1: c-----------c c-----------c ## 2: c-----------c ## r: ##test_intersect_interval_interval_distinct_more <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:10 -> 2015-01-01 12:00:12+")) i2 <- as.nanoival("+2015-01-01 12:00:06 -> 2015-01-01 12:00:07+") r <- as.nanoival(NULL) expect_identical(intersect(i1, i2), r) expect_identical(intersect(i2, i1), r) ## time-time expect_identical(intersect(nanotime(1:10), nanotime(5:15)), nanotime(5:10)) ## union ## -------------------------------------------------------------------------- ## interval - interval: ## 1: c-----------c ## 2: c-----------c ## r: c-----------c ##test_union_interval_interval_cc_cc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- i2 expect_true(union(i1, i2) == r & union(i2, i1) == r) ## 1: c-----------c ## 2: o-----------c ## r: c-----------c ##test_union_interval_interval_cc_oc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- i1 expect_true(union(i1, i2) == r & union(i2, i1) == r) ## 1: c-----------c ## 2: c-----------o ## r: c-----------c ##test_union_interval_interval_cc_co__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- i1 expect_true(union(i1, i2) == r & union(i2, i1) == r) ## 1: c-----------o ## 2: o-----------c ## r: c-----------c ##test_union_interval_interval_co_oc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") expect_true(union(i1, i2) == r & union(i2, i1) == r) ## 1: o-----------o ## 2: o-----------o ## r: o-----------o ##test_union_interval_interval_oo_oo__2_eq_1 <- function() { i1 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- i2 expect_true(union(i1, i2) == r & union(i2, i1) == r) ## 1: c-----------c ## 2: o-----------o ## r: c-----------c ##test_union_interval_interval_cc_oo__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- i1 expect_true(union(i1, i2) == r & union(i2, i1) == r) ## 1: c-----------c ## 2: o-----------o ## 1: c-----------o ## 2: c-----------o ## r: c-----------------------o ##test_union_interval_interval_no_overlap_co_oc <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:05 -> 2015-01-01 12:00:07-") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:07-") expect_identical(union(i1, i2), r) expect_identical(union(i2, i1), r) ## 1: c-----------o ## 2: o-----------o ## r: c-----------o-----------o ##test_union_interval_interval_no_overlap_oo <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:05 -> 2015-01-01 12:00:07-") r <- c(i1, i2) expect_identical(union(i1, i2), r) expect_identical(union(i2, i1), r) ## 1: c-----------c ## 2: c-----------o ## r: c-----------------------o ##test_union_interval_interval_no_overlap_cc <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07-") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:07-") expect_identical(union(i1, i2), r) expect_identical(union(i2, i1), r) ## 1: c-----------c c----------o ## 2: c-----------o o----------c ## r: c-----------------------o ##test_union_interval_interval_no_overlap_cc_more <- function() { i1 <- as.nanoival(c("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+", "+2016-01-01 12:00:03 -> 2016-01-01 12:00:05-")) i2 <- as.nanoival(c("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07-", "-2016-01-01 12:00:04 -> 2016-01-01 12:00:08+")) r <- as.nanoival(c("+2015-01-01 12:00:03 -> 2015-01-01 12:00:07-", "+2016-01-01 12:00:03 -> 2016-01-01 12:00:08+")) expect_identical(union(i1, i2), r) expect_identical(union(i2, i1), r) ## time-time expect_identical(union(nanotime(1:2), nanotime(8:10)), c(nanotime(1:2), nanotime(8:10))) ## setdiff ## -------------------------------------------------------------------------- ## time - interval ## 1: .......... ## 2: c----c ## r: .. .. ##test_sediff_idx_time_interval_cc <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- as.nanoival("+2012-12-12 12:12:14 -> 2012-12-12 12:12:19+") r <- c(1, 2, 9, 10) expect_identical(setdiff.idx(a, idx), r) ## time - interval ## 1: .......... ## 2: o----o ## r: ... ... ##test_sediff_idx_time_interval_oo <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) idx <- as.nanoival("-2012-12-12 12:12:14 -> 2012-12-12 12:12:19-") r <- c(1, 2, 3, 8, 9, 10) expect_identical(setdiff.idx(a, idx), r) ##test_sediff_idx_time_interval_unsorted <- function() { a <- seq(nanotime("2012-12-12 12:12:12"), length.out=10, by=one_second) a[1] <- a[10] # make it unsorted idx <- as.nanoival("-2012-12-12 12:12:14 -> 2012-12-12 12:12:19-") expect_error(setdiff.idx(a, idx), "x must be sorted") ## time - interval: ## 1: as.nanoival("-----------") ## 2: as.nanoival("---") ## r: as.nanoival("--") as.nanoival("----") ##test_setdiff_time_interval_cc__2_subset_of_1 <- function() { s1 <- seq(nanotime("2015-01-01 12:00:00"), length.out=10, by=one_second) i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- c(seq(nanotime("2015-01-01 12:00:00"), length.out=3, by=one_second), seq(nanotime("2015-01-01 12:00:06"), length.out=4, by=one_second)) expect_identical(setdiff(s1, i2), r) ##test_setdiff_time_interval_oc__2_subset_of_1 <- function() { s1 <- seq(nanotime("2015-01-01 12:00:00"), length.out=10, by=one_second) i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- c(seq(nanotime("2015-01-01 12:00:00"), length.out=4, by=one_second), seq(nanotime("2015-01-01 12:00:06"), length.out=4, by=one_second)) expect_identical(setdiff(s1, i2), r) ##test_setdiff_time_interval_co__2_subset_of_1 <- function() { s1 <- seq(nanotime("2015-01-01 12:00:00"), length.out=10, by=one_second) i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- c(seq(nanotime("2015-01-01 12:00:00"), length.out=3, by=one_second), seq(nanotime("2015-01-01 12:00:05"), length.out=5, by=one_second)) expect_identical(setdiff(s1, i2), r) ##test_setdiff_time_interval_oo__2_subset_of_1 <- function() { s1 <- seq(nanotime("2015-01-01 12:00:00"), length.out=10, by=one_second) i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- c(seq(nanotime("2015-01-01 12:00:00"), length.out=4, by=one_second), seq(nanotime("2015-01-01 12:00:05"), length.out=5, by=one_second)) expect_identical(setdiff(s1, i2), r) ## interval - interval: ## 1: c-----------c ## 2: c-----------c ## r: ##test_setdiff_interval_interval_cc_cc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- new("nanoival", as.complex(NULL)) expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: o-----------c ## r: c ##test_setdiff_interval_interval_cc_oc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:03+") expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: c-----------o ## r: c ##test_setdiff_interval_interval_cc_co__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:05+") expect_identical(setdiff(i1, i2), r) ## 1: c-----------o ## 2: o-----------c ## r: c ##test_setdiff_interval_interval_co_oc__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:03+") expect_identical(setdiff(i1, i2), r) ## 1: o-----------o ## 2: o-----------o ## r: ##test_setdiff_interval_interval_oo_oo__2_eq_1 <- function() { i1 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- new("nanoival", as.complex(NULL)) expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: o-----------o ## r: c-----------c ##test_setdiff_interval_interval_cc_oo__2_eq_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:03+"), as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:05+")) expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: c-----------o ## r: c-----------o ##test_setdiff_interval_interval_cc_co__2_gt_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07-") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: o-----------o ## r: c-----------c ##test_setdiff_interval_interval_cc_oo__2_gt_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:05 -> 2015-01-01 12:00:07-") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: o-----------c ## r: c-----------c ##test_setdiff_interval_interval_cc_oc__2_gt_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:05 -> 2015-01-01 12:00:07-") r <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: o-----------c ## r: o-----------c ##test_setdiff_interval_interval_cc_oc__2_lt_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- as.nanoival("-2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: o-----------o ## r: c-----------c ##test_setdiff_interval_interval_cc_oo__2_lt_1 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07+") expect_identical(setdiff(i1, i2), r) ## various tests where we add a third interval ## 1: c-----------c c--------c ## 2: o-----------o ## r: c-----------c c--------c ##test_setdiff_interval_interval_cc_oo__2_lt_1_3rd <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10+")) i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:05-") r <- c(as.nanoival("+2015-01-01 12:00:05 -> 2015-01-01 12:00:07+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10+")) expect_identical(setdiff(i1, i2), r) ## 1: c-----------c c--------o ## 2: o--------------------c ## r: o--------c ##test_setdiff_interval_interval_cc_co_oc_3rd <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:08+") r <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:03+"), as.nanoival("-2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expect_identical(setdiff(i1, i2), r) ## 1: c-----------c ## 2: o-----------o ## r: c-----------c ##test_setdiff_interval_interval_non_overlapping__1_gt_2 <- function() { i1 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") i2 <- as.nanoival("-2015-01-01 12:00:06 -> 2015-01-01 12:00:07-") r <- i1 expect_identical(setdiff(i1, i2), r) ## 1: o-----------o ## 2: c-----------c ## r: o-----------o ##test_setdiff_interval_interval_non_overlapping__2_gt_1 <- function() { i1 <- as.nanoival("-2015-01-01 12:00:06 -> 2015-01-01 12:00:07-") i2 <- as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+") r <- i1 expect_identical(setdiff(i1, i2), r) ## 1: c-----------c c--------c ## 2: o-----------o ## r: c-----------c ##test_setdiff_interval_interval_non_overlapping__1_gt_2_more <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:10 -> 2015-01-01 12:00:12+")) i2 <- as.nanoival("-2015-01-01 12:00:06 -> 2015-01-01 12:00:07-") r <- i1 expect_identical(setdiff(i1, i2), r) ## interval - interval: ## 1: c-----------c c-----------c ## 2: o---------o ## r: ##test_setdiff_interval_interval_2_inside_1__more <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:02 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:10 -> 2015-01-01 12:00:12+")) i2 <- as.nanoival("-2015-01-01 12:00:03 -> 2015-01-01 12:00:04-") r <- c(as.nanoival("+2015-01-01 12:00:02 -> 2015-01-01 12:00:03+"), as.nanoival("+2015-01-01 12:00:04 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:10 -> 2015-01-01 12:00:12+")) expect_identical(setdiff(i1, i2), r) ## interval - interval: ## 1: c------c c--------c ## 2: c---------c ## r: ##test_setdiff_interval_interval_1_inside_2__more <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:02 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:10 -> 2015-01-01 12:00:12+")) i2 <- as.nanoival("+2015-01-01 12:00:01 -> 2015-01-01 12:00:06+") r <- as.nanoival("+2015-01-01 12:00:10 -> 2015-01-01 12:00:12+") expect_identical(setdiff(i1, i2), r) ## time-time expect_identical(setdiff(nanotime(1:10), nanotime(2:9)), c(nanotime(1), nanotime(10))) ## ops +, - ##test_minus_nanoival_any <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expect_error(i1 - "a", "invalid operand types") ##test_minus_nanoival_integer64 <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(as.nanoival("+2015-01-01 12:00:02 -> 2015-01-01 12:00:04+"), as.nanoival("+2015-01-01 12:00:07 -> 2015-01-01 12:00:09-")) expect_identical(i1 - as.integer64(one_second), expected) ##test_minus_nanoival_numeric <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(as.nanoival("+2015-01-01 12:00:02 -> 2015-01-01 12:00:04+"), as.nanoival("+2015-01-01 12:00:07 -> 2015-01-01 12:00:09-")) expect_identical(i1 - one_second, expected) ##test_minus_nanoival_integer <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(as.nanoival("+2015-01-01 12:00:02 -> 2015-01-01 12:00:04+"), as.nanoival("+2015-01-01 12:00:07 -> 2015-01-01 12:00:09-")) expect_identical(i1 - as.integer(one_second), expected) ##test_minus_any_nanoival <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expect_error(as.integer(one_second) - i1, "invalid operand types") ##test_minus_nanoival_nanoival <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expect_error(i1 - i1, "invalid operand types") ##test_plus_nanoival_any <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expect_error(i1 + "a", "invalid operand types") ##test_plus_nanoival_integer64 <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(as.nanoival("+2015-01-01 12:00:04 -> 2015-01-01 12:00:06+"), as.nanoival("+2015-01-01 12:00:09 -> 2015-01-01 12:00:11-")) expect_identical(i1 + as.integer64(one_second), expected) ##test_plus_nanoival_numeric <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(as.nanoival("+2015-01-01 12:00:04 -> 2015-01-01 12:00:06+"), as.nanoival("+2015-01-01 12:00:09 -> 2015-01-01 12:00:11-")) expect_identical(i1 + one_second, expected) ##test_plus_nanoival_integer <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(as.nanoival("+2015-01-01 12:00:04 -> 2015-01-01 12:00:06+"), as.nanoival("+2015-01-01 12:00:09 -> 2015-01-01 12:00:11-")) expect_identical(i1 + as.integer(one_second), expected) ##test_plus_any_nanoival <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expect_error(as.character("a") + i1, "invalid operand types") ##test_plus_nanoival_nanoival <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expect_error(i1 + i1, "invalid operand types") ##test_plus_numeric_nanoival <- function() { i1 <- c(as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(as.nanoival("+2015-01-01 12:00:04 -> 2015-01-01 12:00:06+"), as.nanoival("+2015-01-01 12:00:09 -> 2015-01-01 12:00:11-")) expect_identical(one_second + i1, expected) ##test_plus_integer64_nanoival <- function() { i1 <- c(a=as.nanoival("+2015-01-01 12:00:03 -> 2015-01-01 12:00:05+"), b=as.nanoival("+2015-01-01 12:00:08 -> 2015-01-01 12:00:10-")) expected <- c(a=as.nanoival("+2015-01-01 12:00:04 -> 2015-01-01 12:00:06+"), b=as.nanoival("+2015-01-01 12:00:09 -> 2015-01-01 12:00:11-")) expect_identical(as.integer64(one_second) + i1, expected) ## Groups ##test_Arith_nanoival <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) expect_error(i1 ^ i2, "operation not defined for \"nanoival\" objects") ##test_Compare_nanoival <- function() { i1 <- as.nanoival(aa) expect_error(i1 < 2, "invalid operand types") ##test_Logic_nanoival <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) expect_error(i1 & i2, "operations are possible only for numeric, logical or complex types") expect_error(i1 & 2, "operations are possible only for numeric, logical or complex types") expect_error(1 | i2, "operations are possible only for numeric, logical or complex types") ##test_Math_nanoival <- function() { i1 <- as.nanoival(aa) expect_error(abs(i1), "non-numeric argument to mathematical function") ##test_Math2_nanoival <- function() { i1 <- as.nanoival(aa) expect_error(round(i1), "non-numeric argument to mathematical function") ##test_Summary_nanoival <- function() { i1 <- as.nanoival(aa) expect_error(prod(i1), "invalid 'type' \\(nanoival\\) of argument") ##test_Complex_nanoival <- function() { i1 <- as.nanoival(aa) expect_error(Arg(i1), "non-numeric argument to function") ## Subsetting ##test_subset_logical <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(i1, i2, i3) expect_identical(ii[c(T,F,T)], c(i1, i3)) expect_identical(ii[c(T,F,NA)], c(i1, NA_nanoival_)) expect_identical(ii[-1], c(i2, i3)) expect_warning(ii[c(T,F,T), 3], "unused indices or arguments in 'nanoival' subsetting") ##test_subset_logical_named <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(a=i1, b=i2, c=i3) expect_identical(ii[c(T,F,T)], c(a=i1, c=i3)) ##test_subset_numeric <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(i1, i2, i3) expect_identical(ii[c(1,3)], c(i1, i3)) expect_identical(ii[c(1,NA)], c(i1, NA_nanoival_)) expect_warning(ii[c(1,3), 3, 5], "unused indices or arguments in 'nanoival' subsetting") ##test_subset_numeric_named <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(a=i1, b=i2, c=i3) expect_identical(ii[c(1,3)], c(a=i1, c=i3)) ## test subset character i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(a=i1, b=i2, c=i3) expect_identical(ii[c("a","b")], ii[1:2]) res <- c(a=i1, NA_nanoival_) names(res)[2] <- NA_character_ expect_identical(ii[c("a","x")], res) expect_warning(ii["a", "b"], "unused indices or arguments in 'nanoival' subsetting") ## test subset error expect_error(as.nanoival(aa)[as.integer64(1)], "']' not defined for on 'nanoival' for index of type 'ANY'") ##test_subassign_logical <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(i1, i2, i3) ii[c(F,T,T)] <- i1 expect_identical(ii, c(i1, i1, i1)) ##test_subassign_logical_named <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(a=i1, b=i2, c=i3) ii[c(F,T,T)] <- i1 expect_identical(ii, c(a=i1, b=i1, c=i1)) ##test_subassign_numeric <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(i1, i2, i3) ii[2:3] <- i1 expect_identical(ii, c(i1, i1, i1)) ##test_subassign_numeric_named <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(a=i1, b=i2, c=i3) ii[2:3] <- i1 expect_identical(ii, c(a=i1, b=i1, c=i1)) ##test_square_bracket <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) nn <- c(a=i1, b=i2, c=i3) nn_nonames <- c(i1, i2, i3) expect_identical(nn_nonames[1], nn[[1]]) expect_identical(nn_nonames[2], nn[[2]]) expect_identical(nn_nonames[3], nn[[3]]) ## transposition, which is identity, as for 'POSIXct' for example: ##test_t_nanoival <- function() { i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) i3 <- as.nanoival(cc) ii <- c(a=i1, b=i2, c=i3) expect_identical(t(ii), ii) ## NA stuff expect_true(is.na(nanoival(NA_nanotime_, NA_nanotime_, NA, NA))) expect_true(is.na(nanoival(NA_nanotime_, nanotime(1), TRUE, TRUE))) expect_true(is.na(nanoival(nanotime(1), NA_nanotime_, TRUE, TRUE))) expect_true(is.na(nanoival(nanotime(1), nanotime(2), NA, TRUE))) expect_true(is.na(nanoival(nanotime(1), nanotime(2), TRUE, NA))) nn <- nanoival(nanotime(1:10), nanotime(2:11)) is.na(nn) <- 1:3 expect_true(all(is.na(nn[1:3]))) expect_true(!any(is.na(nn[4:10]))) expect_true(is.na(NA_nanoival_)) expect_true(is.na(nanoival.start(NA_nanoival_))) expect_true(is.na(nanoival.end(NA_nanoival_))) expect_true(is.na(nanoival.sopen(NA_nanoival_))) expect_true(is.na(nanoival.eopen(NA_nanoival_))) ## overflow n1 <- nanotime(1) n2 <- nanotime(2) ni <- nanoival(n1, n2) prd <- as.nanoperiod("200y") if (!isSolaris) { expect_warning(plus (ni, prd, "America/New_York"), "NAs produced by time overflow \\(remember that interval times are coded with 63 bits\\)") expect_warning(minus(ni, prd, "America/New_York"), "NAs produced by time overflow \\(remember that interval times are coded with 63 bits\\)") } dur <- as.nanoduration(200*365*24*3600*1e9) expect_warning(ni + dur, "NAs produced by time overflow \\(remember that interval times are coded with 63 bits\\)") expect_warning(ni + dur, "NAs produced by time overflow \\(remember that interval times are coded with 63 bits\\)") ## test warnings for ops where the vectors have length mismatch: ##test_lt_size_mismatch <- function() { x <- nanoival(nanotime(1), nanotime(2)) expect_warning(c(x,x) < c(x,x,x), "longer object length is not a multiple of shorter object length") d <- as.nanoduration(1) expect_warning(c(x,x,x) + c(d,d), "longer object length is not a multiple of shorter object length") ## warnings should also happen on 'nanoival' construction: s <- nanotime(1) e <- nanotime(2) expect_warning(nanoival(c(s,s), c(e,e,e)), "longer object length is not a multiple of shorter object length") expect_warning(nanoival(c(s,s), c(e,e), c(T,T,T)), "longer object length is not a multiple of shorter object length") expect_warning(nanoival(c(s,s), c(e,e), c(T,T), c(F,F,F)), "longer object length is not a multiple of shorter object length") ## test that recycling is really correct, despite the warning: s <- nanotime(1e9) e <- nanotime(2e9) ni <- nanoival(s, e) + as.nanoduration(1:5*1e9) d <- as.nanoduration(1:2*1e9) expect_identical(ni + d, ni + c(d, d, d[1])) ## test S4 conversions: expect_identical(as.nanoival(aa), as(aa, "nanoival")) ## test seq: x <- as.nanoival("+2013-01-01 15:00:00 -> 2013-01-01 17:00:00-") if (!isSolaris) { expect_identical(seq(x, by=as.nanoperiod("1m"), length.out=4, tz="America/New_York"), nanoival(seq(nanoival.start(x), by=as.nanoperiod("1m"), length.out=4, tz="America/New_York"), seq(nanoival.end(x), by=as.nanoperiod("1m"), length.out=4, tz="America/New_York"), FALSE, TRUE)) } y <- as.nanoival("+2013-01-04 15:00:00 -> 2013-01-04 17:00:00-") expect_identical(seq(x, y, by=as.nanoduration("24:00:00")), nanoival(seq(nanoival.start(x), by=as.nanoperiod("1d"), length.out=4, tz="UTC"), seq(nanoival.end(x), by=as.nanoperiod("1d"), length.out=4, tz="UTC"), FALSE, TRUE)) expect_identical(seq(x, y, length.out=4), nanoival(seq(nanoival.start(x), by=as.nanoperiod("1d"), length.out=4, tz="UTC"), seq(nanoival.end(x), by=as.nanoperiod("1d"), length.out=4, tz="UTC"), FALSE, TRUE)) ## 0-length ops: ## ------------ ## constructor: expect_identical(nanoival(nanotime(), nanotime(1)), nanoival()) expect_identical(nanoival(nanotime(), nanotime()), nanoival()) expect_identical(nanoival(nanotime(1), nanotime()), nanoival()) expect_identical(nanoival(nanotime(1), nanotime(2), logical()), nanoival()) expect_identical(nanoival(nanotime(1), nanotime(2), logical(), logical()), nanoival()) expect_identical(nanoival(nanotime(), nanotime(), logical(), logical()), nanoival()) expect_identical(as.nanoival(character()), nanoival()) ## Comp: expect_identical(nanoival(nanotime(1), nanotime(2)) > nanoival(), logical()) expect_identical(nanoival(nanotime(1), nanotime(2)) < nanoival(), logical()) expect_identical(nanoival() <= nanoival(nanotime(1), nanotime(2)) , logical()) expect_identical(nanoival() != nanoival(nanotime(1), nanotime(2)) , logical()) ## ops expect_identical(nanoival(nanotime(1), nanotime(2)) + integer(), as.nanoival()) expect_identical(nanoival(nanotime(1), nanotime(2)) - integer(), as.nanoival()) expect_identical(integer() + nanoival(), as.nanoival()) ## accessors expect_identical(nanoival.start(nanoival()), nanotime()) expect_identical(nanoival.end(nanoival()), nanotime()) expect_identical(nanoival.sopen(nanoival()), logical()) expect_identical(nanoival.eopen(nanoival()), logical()) ## set ops: expect_identical(union(nanoival(nanotime(1), nanotime(2)), nanoival()), nanoival(nanotime(1), nanotime(2))) expect_identical(intersect(nanoival(nanotime(1), nanotime(2)), nanoival()), nanoival()) expect_identical(setdiff(nanoival(nanotime(1), nanotime(2)), nanoival()), nanoival(nanotime(1), nanotime(2))) expect_identical(setdiff.idx(nanotime(), nanoival()), numeric()) expect_identical(setdiff.idx(nanotime(1), nanoival()), 1) expect_identical(setdiff.idx(nanotime(), nanoival(nanotime(1), nanotime(2))), numeric()) expect_identical(intersect(nanotime(1), nanoival()), nanotime()) expect_identical(intersect(nanotime(), nanoival(nanotime(1), nanotime(2))), nanotime()) expect_identical(intersect.idx(nanotime(1), nanoival()), list(x=numeric(), y=numeric())) expect_identical(intersect.idx(nanotime(), nanoival(nanotime(1), nanotime(2))), list(x=numeric(), y=numeric())) expect_identical(nanotime() %in% nanoival(nanotime(1), nanotime(2)), logical(0)) expect_identical(nanotime(1:10) %in% nanoival(), rep(FALSE, 10)) expect_identical(is.na(as.nanoival()), logical()) ## all.equal: expect_identical(all.equal(nanoival(nanotime(1), nanotime(2)), nanoival(nanotime(1), nanotime(2))), TRUE) expect_false(isTRUE(all.equal(nanoival(nanotime(1), nanotime(2)), "A"))) expect_identical(all.equal(nanoival(nanotime(1), nanotime(2)), NA_nanoival_), "'is.NA' value mismatch: 1 in current 0 in target") ## rep i1 <- as.nanoival(aa) i2 <- as.nanoival(bb) expect_identical(rep(i1, 2), c(i1, i1)) expect_identical(rep(c(i1,i2), each=2), c(i1, i1, i2, i2)) options(nanotimeFormat=savedFormat) nanotime/inst/tinytest/test_nanotime.R0000644000176200001440000007707114131560240017730 0ustar liggesusers suppressMessages({ library(nanotime) library(bit64) }) options(digits=7) # needed for error message of 0.3333333 below expect_equal_numeric <- function(x,y,...) expect_equal(as.numeric(x), as.numeric(y), ...) isSolaris <- Sys.info()[["sysname"]] == "SunOS" ## nanotime constructors ##test_nanotime_generic <- function() { expect_identical(S3Part(nanotime(1), strict=TRUE), as.integer64(1)) expect_identical(nanotime(1), new("nanotime", as.integer64(1))) expect_identical(nanotime(as.integer64(1)), new("nanotime", as.integer64(1))) expect_identical(as.nanotime(1), new("nanotime", as.integer64(1))) expect_identical(as.nanotime(as.integer64(1)), new("nanotime", as.integer64(1))) ##test_nanotime_character_first_pass <- function() { ## we do a first pass parsing, which is faster than the parsing ## with the format string, and is also more forgiving if (!isSolaris) { expect_identical(nanotime("2018-01-01T05:00:00.99 Europe/London"), nanotime(as.integer64("1514782800990000000"))) expect_identical(nanotime("2018-01-01T05:00:00.999_999_999 America/New_York"), nanotime(as.integer64("1514800800999999999"))) expect_identical(nanotime("2018-01-01T05:00:00.999_999 America/New_York"), nanotime(as.integer64("1514800800999999000"))) expect_identical(nanotime("2018-01-01T05:00:00.999 America/New_York"), nanotime(as.integer64("1514800800999000000"))) expect_identical(nanotime("2018-01-01T05:00:00 America/New_York"), nanotime(as.integer64("1514800800000000000"))) expect_identical(nanotime("2018-01-01 05:00:00 America/New_York"), nanotime(as.integer64("1514800800000000000"))) expect_identical(nanotime("2018-01-01 05:00:00 America/New_York"), nanotime(as.integer64("1514800800000000000"))) expect_identical(nanotime("2018-01-01 America/New_York"), nanotime(as.integer64("1514782800000000000"))) expect_identical(nanotime("2018-01-01T05:00:00.99+00:00"), nanotime(as.integer64("1514782800990000000"))) expect_identical(nanotime("2018-01-01T05:00:00.99-00:00"), nanotime(as.integer64("1514782800990000000"))) expect_identical(nanotime("2018-01-01T05:00:00.999_999_999+05:00"), nanotime(as.integer64("1514764800999999999"))) expect_identical(nanotime("2018-01-01T05:00:00.999_999+05:00"), nanotime(as.integer64("1514764800999999000"))) expect_identical(nanotime("2018-01-01T05:00:00.999+05:00"), nanotime(as.integer64("1514764800999000000"))) expect_identical(nanotime("2018-01-01T05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(nanotime("2018-01-01 05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(nanotime("2018-01-01 05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(nanotime("2018-01-01 05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(nanotime("2018-01-01+05:00"), nanotime(as.integer64("1514746800000000000"))) expect_identical(nanotime("2018/01/01T05:00:00.99 Europe/London"), nanotime(as.integer64("1514782800990000000"))) expect_identical(nanotime("2018 01 01T05:00:00.99 Europe/London"), nanotime(as.integer64("1514782800990000000"))) ## test the alias 'as.nanotime': expect_identical(as.nanotime("2018-01-01T05:00:00.99 Europe/London"), nanotime(as.integer64("1514782800990000000"))) expect_identical(as.nanotime("2018-01-01T05:00:00.999_999_999 America/New_York"), nanotime(as.integer64("1514800800999999999"))) expect_identical(as.nanotime("2018-01-01T05:00:00.999_999 America/New_York"), nanotime(as.integer64("1514800800999999000"))) expect_identical(as.nanotime("2018-01-01T05:00:00.999 America/New_York"), nanotime(as.integer64("1514800800999000000"))) expect_identical(as.nanotime("2018-01-01T05:00:00 America/New_York"), nanotime(as.integer64("1514800800000000000"))) expect_identical(as.nanotime("2018-01-01 05:00:00 America/New_York"), nanotime(as.integer64("1514800800000000000"))) expect_identical(as.nanotime("2018-01-01 05:00:00 America/New_York"), nanotime(as.integer64("1514800800000000000"))) expect_identical(as.nanotime("2018-01-01 America/New_York"), nanotime(as.integer64("1514782800000000000"))) expect_identical(as.nanotime("2018-01-01T05:00:00.99+00:00"), nanotime(as.integer64("1514782800990000000"))) expect_identical(as.nanotime("2018-01-01T05:00:00.99-00:00"), nanotime(as.integer64("1514782800990000000"))) expect_identical(as.nanotime("2018-01-01T05:00:00.999_999_999+05:00"), nanotime(as.integer64("1514764800999999999"))) expect_identical(as.nanotime("2018-01-01T05:00:00.999_999+05:00"), nanotime(as.integer64("1514764800999999000"))) expect_identical(as.nanotime("2018-01-01T05:00:00.999+05:00"), nanotime(as.integer64("1514764800999000000"))) expect_identical(as.nanotime("2018-01-01T05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(as.nanotime("2018-01-01 05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(as.nanotime("2018-01-01 05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(as.nanotime("2018-01-01 05:00:00+05:00"), nanotime(as.integer64("1514764800000000000"))) expect_identical(as.nanotime("2018-01-01+05:00"), nanotime(as.integer64("1514746800000000000"))) expect_identical(as.nanotime("2018/01/01T05:00:00.99 Europe/London"), nanotime(as.integer64("1514782800990000000"))) expect_identical(as.nanotime("2018 01 01T05:00:00.99 Europe/London"), nanotime(as.integer64("1514782800990000000"))) expect_identical(as.nanotime(NULL), nanotime()) expect_identical(as.nanotime(NULL), as.nanotime()) ##test_nanotime_character_first_pass_fail <- function() { ## none of these should parse expect_error(nanotime("2018-01-01T05:00:00.99 America/New_dYork"), "Cannot retrieve timezone") expect_error(nanotime("2018--01-01T05:00:00.99 America/New_York"), "Parse error") expect_error(nanotime("2018-01-01T05:00:00.99 America/New_York s"), "Parse error") expect_error(nanotime("2018-01-01T05:00:s0.99 America/New_York"), "Parse error") expect_error(nanotime("2018-01-01T05:00:00.a99 America/New_York"), "Parse error") expect_error(nanotime("2018-01-01T05:00:00.0000000000 America/New_York"), "Parse error") expect_error(nanotime("201"), "Parse error") expect_error(nanotime("2018-13-01T05:00:00.99 Europe/London"), "Parse error") expect_error(nanotime("2018"), "Parse error") expect_error(nanotime("2018-1"), "Parse error") expect_error(nanotime("2018-01-32T05:00:00.99 Europe/London"), "Parse error") expect_error(nanotime("2018-01-01T25:00:00.99 Europe/London"), "Parse error") expect_error(nanotime("2018-01-01T05:61:00.99 Europe/London"), "Parse error") expect_error(nanotime("2018-01-01T05:00:61.99 Europe/London"), "Parse error") expect_error(nanotime("2018-01-01T05:00:00.99999999999 Europe/London"), "Parse error") expect_error(nanotime("2018-01-01T05:00:00.99 Europe/London%"), "Parse error") expect_error(nanotime("2018-01-01T05:00:00.99 %"), "Parse error") expect_error(as.nanotime("2013-01-01 00:00:00 America/New_York", tz="Europe/London"), "timezone is specified twice: in the string and as an argument") } ##test_nanotime_character_second_pass <- function() { ## if the parsing above has failed, then we use a second parsing ## that is based on the format string that is provided if (!isSolaris) { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") ## check that the format and time zone is picked up from the global options: options(nanotimeFormat="%Y|%m|%d %H:%M") options(nanotimeTz="America/New_York") expect_identical(nanotime("1970|01|01 00:00"), nanotime(18000000000000)) ## check they are overridden by the parameters: expect_identical(nanotime("1970|01|01 00:00:01", format="%Y|%m|%d %H:%M:%S", tz="Europe/Paris"), nanotime(-3599000000000)) options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) } ##test_nanotime_character_second_pass_fail <- function() { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") ## check that the format and time zone is picked up from the global options: options(nanotimeFormat="%Y|%m|%d %H:%M") options(nanotimeTz="America/New_York") expect_error(nanotime("1970-01-01 00:00"), "Parse error on 1970-01-01 00:00") ## check they are overridden by the parameters: expect_error(nanotime("1970-01-01 00:00", format="%Y|%m|%d %H:%M:%S", tz="Europe/Paris"), "Parse error") options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) ##test_nanotime_matrix <- function() { if (!isSolaris) { m <- matrix(c(10*24*3600+0:9, 987654321+0:9), 10, 2) expect_identical(nanotime.matrix(m), nanotime("1970-01-11T00:00:00.987654321+00:00") + seq(0, 9e9, by=1e9) + 0:9) } ##test_nanotime_POSIXct <- function() { p <- as.POSIXct("1970-01-01 00:00:00", tz="America/New_York") expect_identical(nanotime(p), nanotime("1970-01-01T00:00:00.000000000-05:00")) expect_identical(as.nanotime(p), nanotime("1970-01-01T00:00:00.000000000-05:00")) ##test_nanotime_POSIXlt <- function() { l <- as.POSIXlt("1970-01-01 00:00:00", tz="America/New_York") expect_identical(nanotime(l), nanotime("1970-01-01T00:00:00.000000000-05:00")) expect_identical(as.nanotime(l), nanotime("1970-01-01T00:00:00.000000000-05:00")) ##test_nanotime_Date <- function() { d <- as.Date(10, origin="1970-01-01") expect_identical(nanotime(d), nanotime("1970-01-11T00:00:00.000000000-00:00")) expect_identical(as.nanotime(d), nanotime("1970-01-11T00:00:00.000000000-00:00")) ##test_nanotime_numeric_keep_names <- function() { n <- nanotime(c(a=1, b=2)) expect_identical(names(n), c("a","b")) ##test_nanotime_character_keep_names <- function() { if (!isSolaris) { n <- nanotime(c(a="1970-01-01T00:00:00.000000001+00:00", b="1970-01-01T00:00:00.000000001+00:00")) expect_identical(names(n), c("a","b")) } ##test_nanotime_POSIXct_keep_names <- function() { p <- as.POSIXct("1970-01-01 00:00:00", tz="America/New_York") n <- nanotime(c(a=p, b=p)) expect_identical(names(n), c("a","b")) ##test_nanotime_POSIXlt_keep_names <- function() { l <- as.POSIXlt("1970-01-01 00:00:00", tz="America/New_York") n <- nanotime(c(a=l, b=l)) expect_identical(names(n), c("a","b")) ## format, and as.character ##test_format_default <- function() { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") options(nanotimeFormat=NULL) options(nanotimeTz=NULL) expect_identical(format(nanotime("1970-01-01T00:00:00.000000000+00:00")), "1970-01-01T00:00:00+00:00") expect_identical(format(nanotime("1680-07-17T00:00:01.000000000+00:00")), "1680-07-17T00:00:01+00:00") expect_identical(format(nanotime("2120-01-01T00:00:59.987654321+00:00")), "2120-01-01T00:00:59.987654321+00:00") expect_identical(format(nanotime(NULL)), "nanotime(0)") expect_identical(as.character(nanotime("1970-01-01T00:00:00.000000000+00:00")), "1970-01-01T00:00:00+00:00") expect_identical(as.character(nanotime("1680-07-17T00:00:01.000000000+00:00")), "1680-07-17T00:00:01+00:00") expect_identical(as.character(nanotime("2120-01-01T00:00:59.987654321+00:00")), "2120-01-01T00:00:59.987654321+00:00") expect_identical(as.character(format(nanotime(NULL))), "nanotime(0)") options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) ##test_format_tz <- function() { if (!isSolaris) { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") options(nanotimeFormat=NULL) a_utc = "1970-01-01T00:00:00+00:00" nt <- nanotime(a_utc) a_ny <- "1969-12-31T19:00:00-05:00" options(nanotimeTz=NULL) expect_identical(format(nt, tz="America/New_York"), a_ny) options(nanotimeTz="UTC") expect_identical(format(nt, tz="America/New_York"), a_ny) attr(nt, "tzone") <- "UTC" expect_identical(format(nt, tz="America/New_York"), a_ny) expect_identical(format(nt, tz=""), a_utc) options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) } ##test_format_tzone <- function() { if (!isSolaris) { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") options(nanotimeFormat=NULL) a <- nanotime("1970-01-01T00:00:00.001000000+00:00") attr(a, "tzone") <- "America/New_York" a_ny <- "1969-12-31T19:00:00.001-05:00" expect_identical(format(a), a_ny) options(nanotimeTz="UTC") expect_identical(format(a), a_ny) options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) } ##test_format_tz_from_options <- function() { if (!isSolaris) { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") options(nanotimeFormat=NULL) options(nanotimeTz="America/New_York") a <- nanotime("1970-01-01T00:00:00.000001000+00:00") a_ny <- "1969-12-31T19:00:00.000001-05:00" expect_identical(format(a), a_ny) options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) } ##test_format_fmt_default <- function() { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") options(nanotimeFormat=NULL) options(nanotimeTz=NULL) a_str <- "1970-01-01T00:00:00+00:00" a <- nanotime(a_str) expect_identical(format(a), a_str) options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) ##test_format_fmt_from_options <- function() { if (!isSolaris) { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") options(nanotimeFormat="%Y/%m/%dT%H:%M:%E9S%Ez") options(nanotimeTz="America/New_York") a <- nanotime("1970/01/01T00:00:00.000000000+00:00") a_ny <- "1969/12/31T19:00:00.000000000-05:00" expect_identical(format(a), a_ny) options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) } ##test_format_fmt_from_parameter <- function() { if (!isSolaris) { oldFormat <- getOption("nanotimeFormat") oldTz <- getOption("nanotimeTz") options(nanotimeFormat="%Y/%m/%dT%H:%M:%E9S%Ez") options(nanotimeTz="America/New_York") a <- nanotime("1970-01-01 00:00:00.000000000+00:00", format="%Y-%m-%d %H:%M:%E9S%Ez") # the result of format on a is taken from the global option: a_ny <- "1969/12/31T19:00:00.000000000-05:00" expect_identical(format(a), a_ny) options(nanotimeFormat=oldFormat) options(nanotimeTz=oldTz) } ##test_format_na <- function() { if (FALSE && !isSolaris) { f <- format(nanotime(c(1, NA, 2, NaN))) exp <- c("1970-01-01T00:00:00.000000001+00:00", as.character(NA), "1970-01-01T00:00:00.000000002+00:00", as.character(NA)) expect_identical(f, exp) } ## conversions ##test_as_POSIXct <- function() { a <- nanotime(0) attr(a, "tzone") <- "America/New_York" p <- as.POSIXct(a) expect_identical(p, as.POSIXct("1969-12-31 19:00:00", tz="America/New_York")) oldTz <- getOption("nanotimeTz") options(nanotimeTz="America/New_York") b <- nanotime(0) p <- as.POSIXct(b) ## LLL: not fully satisfactory here; nanotime will not have 'tz' set from the environment: expect_equal(p, as.POSIXct("1969-12-31 19:00:00", tz="America/New_York"), check.tzone=FALSE) options(nanotimeTz=NULL) c <- nanotime(0) p <- as.POSIXct(c) expect_equal(p, as.POSIXct("1970-01-01 00:00:00", tz="UTC"), check.tzone=FALSE) options(nanotimeTz=oldTz) ##test_as_Date <- function() { expect_identical(as.Date(nanotime(0)), as.Date("1970-01-01")) ## c, subset, subassign and binds ##test_c <- function() { a <- c(nanotime(1), nanotime(2)) expect_identical(a, nanotime(1:2)) a <- c(nanotime(1:2), nanotime(3:4)) expect_identical(a, nanotime(1:4)) ## subset ## subset integer a <- nanotime(1:10) expect_identical(a[3], nanotime(3)) expect_identical(a[1:10], a) expect_identical(a[c(1:3, NA)], c(nanotime(1:3), NA_nanotime_)) expect_identical(a[11], NA_nanotime_) expect_identical(a[c(0, 2)], as.nanotime(2)) expect_warning(a[1, 2], "unused indices or arguments in 'nanotime' subsetting") expect_error(a[c(1,-2)], "only 0's may be mixed with negative subscripts") expect_error(a[c(-1, 2)], "only 0's may be mixed with negative subscripts") names(a) <- paste0("a", 1:10) expect_identical(a[c(1,10)], c(a1=as.nanotime(1), a10=as.nanotime(10))) res <- c(a1=as.nanotime(1), a10=as.nanotime(10), NA) names(res)[3] <- NA_character_ expect_identical(a[c(1,10,NA)], res) expect_identical(a[11], res[3]) ## subset logical a <- nanotime(1:10) expect_identical(a[c(T,F)], nanotime(c(1,3,5,7,9))) expect_identical(a[c(T,F,F,F,NA)], nanotime(c(1, NA, 6, NA))) expect_identical(a[c(1:3, NA)], c(nanotime(1:3), NA_nanotime_)) expect_warning(a[T, F], "unused indices or arguments in 'nanotime' subsetting") names(a) <- paste0("a", 1:10) expect_identical(a[c(T,F,F,F,F)], a[c(1,6)]) res <- c(a1=as.nanotime(1), NA) names(res)[2] <- NA_character_ expect_identical(a[c(T,F,F,F,F,F,F,F,F,NA)], res) ## subset named character a <- nanotime(1:10) names(a) <- paste0("a", 1:10) expect_identical(a[c("a1", "a3", "a6")], a[c(1,3,6)]) expect_identical(a[c("a1", "a3", NA)], a[c(1,3,NA)]) expect_identical(a[c("a1", "a3", "a11")], a[c(1,3,NA)]) expect_warning(a["a", "b"], "unused indices or arguments in 'nanotime' subsetting") ## subset error a <- nanotime(1:10) expect_error(a[as.integer64(1)], "']' not defined on 'nanotime' for index of type 'ANY'") ##test_subsassign <- function() { a <- nanotime(1:10) a[3] <- nanotime(13) expect_identical(a[3], nanotime(13)) a[1:10] <- nanotime(10:1) expect_identical(a[1:10], nanotime(10:1)) ## summary ##test_summary <- function() { expected <- nanotime(c(1,2,2,2,3,4)) names(expected) <- c("Min.", "1st Qu.", "Median", "Mean", "3rd Qu.", "Max.") expect_identical(summary(nanotime(1:4)), expected) expected <- nanotime(c(1,2,3,3,4,5)) names(expected) <- c("Min.", "1st Qu.", "Median", "Mean", "3rd Qu.", "Max.") expect_identical(summary(nanotime(1:5)), expected) ## Arith ##test_unary_minus <- function() { expect_error(-nanotime(1), "unary '-' is not defined for \\\"nanotime\\\" objects") ##test_unary_plus <- function() { expect_error(+nanotime(1), "unary '\\+' is not defined for \\\"nanotime\\\" objects") ##test_ANY_minus_nano <- function() { expect_error(1 - nanotime(2), "invalid operand types") ##test_nano_minus_nanoperiod <- function() { msg <- paste0("binary '\\-' is not defined for 'nanotime' and 'nanoperiod' objects; instead use 'minus\\(e1, e2, tz\\)'") expect_error(nanotime(1) - as.nanoperiod("2m"), msg) ##test_nano_minus_ANY <- function() { expect_error(nanotime(1) - "a", "invalid operand types") ##test_nano_minus_nanoduration <- function() { nt <- nanotime(2000) expect_identical(nt - as.nanoduration(2000), nanotime(0)) ## + ##test_ANY_plus_nano <- function() { expect_error("a" + nanotime(2), "invalid operand types") ##test_nano_plus_ANY <- function() { expect_error(nanotime(1) + "a", "invalid operand types") ##test_nano_plus_nanoperiod <- function() { msg <- paste0("binary '\\+' is not defined for 'nanotime' and 'nanoperiod' objects; instead use 'plus\\(e1, e2, tz\\)'") expect_error(nanotime(1) + as.nanoperiod("2m"), msg) ##test_nano_plus_nanoduration <- function() { nt <- nanotime(2000) expect_identical(nt + as.nanoduration(2000), nanotime(4000)) ## * ##test_nano_mul_nano <- function() { expect_error(nanotime(1) * nanotime(1), "operation not defined for \"nanotime\" objects") ##test_nano_mul_nano <- function() { expect_error(nanotime(1) * nanotime(2), "operation not defined for \"nanotime\" objects") ##test_nano_mul_ANY <- function() { expect_error(nanotime(1) * 1, "operation not defined for \"nanotime\" objects") ##test_nano_div_ANY <- function() { ## div is in the same 'Arith' group as mul: expect_error(nanotime(1) / 1, "operation not defined for \"nanotime\" objects") ##test_nano_Logic_ANY <- function() { expect_error(nanotime(1) | 1, "operations are possible only for numeric, logical or complex types") ##test_ANY_Logic_nano <- function() { expect_error(1 | nanotime(1), "operations are possible only for numeric, logical or complex types") ##test_Math_nano <- function() { expect_error(sin(nanotime(1)), "non-numeric argument to mathematical function") ##test_Math2_nano <- function() { expect_error(round(nanotime(1)), "non-numeric argument to mathematical function") ## miscellaneous ##test_is.na <- function() { expect_true(is.na(nanotime(NA))) expect_true(is.na(nanotime(NaN))) nn <- nanotime(1:10) is.na(nn) <- 1:3 expect_true(all(is.na(nn[1:3]))) expect_true(!any(is.na(nn[4:10]))) expect_true(is.na(NA_nanotime_)) ## test square bracket (#44) ##test_square_bracket <- function() { if (!isSolaris) { times <- c(nanotime('2011-12-05 08:30:00.000',format ="%Y-%m-%d %H:%M:%E9S", tz ="GMT"), nanotime('2011-12-05 08:30:00.100',format ="%Y-%m-%d %H:%M:%E9S", tz ="GMT"), nanotime('2011-12-05 08:30:00.825',format ="%Y-%m-%d %H:%M:%E9S", tz ="GMT")) expect_identical(times[1], times[[1]]) expect_identical(times[2], times[[2]]) expect_identical(times[3], times[[3]]) } ## test compare expect_true(nanotime(1) == nanotime(1)) expect_true(nanotime(1) != nanotime(2)) expect_true(nanotime(1) <= nanotime(1)) expect_true(nanotime(1) >= nanotime(1)) expect_true(nanotime(1) <= nanotime(2)) expect_false(nanotime(1) >= nanotime(2)) expect_true(nanotime(1) < nanotime(2)) expect_false(nanotime(1) > nanotime(2)) ## with character expect_true(nanotime(1) == nanotime("1970-01-01T00:00:00.000000001+00")) expect_true(nanotime("1970-01-01T00:00:00.000000001+00") != nanotime(2)) expect_true(nanotime("1970-01-01T00:00:00.000000001+00") <= nanotime(1)) expect_true(nanotime("1970-01-01T00:00:00.000000001+00") >= nanotime(1)) expect_true(nanotime(1) <= nanotime("1970-01-01T00:00:00.000000002+00")) expect_false(nanotime("1970-01-01T00:00:00.000000001+00") >= nanotime(2)) expect_true(nanotime(1) < nanotime("1970-01-01T00:00:00.000000002+00")) expect_false(nanotime("1970-01-01T00:00:00.000000001+00") > nanotime(2)) if (isSolaris) exit_file("skip remainder on Solaris") ## with POSIXt pt1 <- as.POSIXct(1, origin="1970-01-01", tz="UTC") pt2 <- as.POSIXct(2, origin="1970-01-01", tz="UTC") expect_true(pt1 == nanotime("1970-01-01T00:00:01+00")) expect_true(nanotime("1970-01-01T00:00:01+00") != pt2) expect_true(nanotime("1970-01-01T00:00:01+00") <= pt1) expect_true(nanotime("1970-01-01T00:00:01+00") >= pt1) expect_true(nanotime(1) <= nanotime("1970-01-01T00:00:02+00")) expect_false(nanotime("1970-01-01T00:00:01+00") >= pt2) expect_true(nanotime(1) < nanotime("1970-01-01T00:00:00.000000002+00")) expect_false(nanotime("1970-01-01T00:00:01+00") > pt2) ## all.equal ##test_all.equal_nanotime_any <- function() { expect_true(!isTRUE(all.equal(nanotime(1), "a"))) ##test_all.equal_any_nanotime <- function() { expect_true(!isTRUE(all.equal("a", nanotime(1)))) ##test_all.equal_nanotime_nanotime <- function() { expect_true(isTRUE(all.equal(nanotime(1), nanotime(1)))) expect_true(!isTRUE(all.equal(nanotime(1), nanotime(2)))) expect_identical(all.equal(nanotime(1), nanotime(2)), "Mean relative difference: 1") expect_identical(all.equal(nanotime(c(1L,NA)), nanotime(1:2)), "'is.NA' value mismatch: 0 in current 1 in target") expect_error(all.equal(nanotime(1), nanotime(1), tolerance="1"), "'tolerance' should be numeric") expect_error(all.equal(nanotime(1), nanotime(1), scale="1"), "'scale' should be numeric or NULL") expect_error(all.equal(nanotime(1), nanotime(1), check.attributes="1"), "'check.attributes' must be logical") expect_error(all.equal(nanotime(1), nanotime(2), scale=-1), "all\\(scale > 0\\) is not TRUE") expect_false(isTRUE(all.equal(nanotime(1), as.nanoperiod("1d")))) expect_identical(all.equal(nanotime(1), nanotime(1:2)), "Numeric: lengths (1, 2) differ") expect_identical(all.equal(nanotime(c(1,2,3)), nanotime(c(1,1,2)), countEQ=TRUE), "Mean relative difference: 0.3333333") expect_false(isTRUE(all.equal(nanotime(1), 1i))) expect_identical(all.equal(nanotime(1), nanotime(3), tolerance=1), "Mean absolute difference: 2") expect_identical(all.equal(nanotime(1), nanotime(2e9), scale=1e9), "Mean scaled difference: 2") expect_identical(all.equal(nanotime(1), nanotime(2e9), scale=1), "Mean absolute difference: 2e+09") ## test S4 conversions: ## to 'nanotime': expect_identical(as("2018-01-01T05:00:00.99 Europe/London", "nanotime"), nanotime(as.integer64("1514782800990000000"))) expect_identical(as(as.Date(10, origin="1970-01-01"), "nanotime"), nanotime("1970-01-11T00:00:00.000000000-00:00")) expect_identical(as(as.integer64("1514782800990000000"), "nanotime"), nanotime("2018-01-01T05:00:00.99 Europe/London")) expect_identical(as(as.POSIXct(1514782800, origin="1970-01-01", tz="UTC"), "nanotime"), nanotime("2018-01-01T05:00:00 Europe/London")) expect_identical(as(as.POSIXlt(as.POSIXct(1514782800, origin="1970-01-01", tz="UTC")), "nanotime"), nanotime("2018-01-01T05:00:00 Europe/London")) ## from 'nanotime': expect_identical(as(nanotime("1970-01-11T00:00:00.000000000-00:00"), "Date"), as.Date("1970-01-11")) ## don't run this one, it's only right when run in America/New_York timezone! ## expect_identical(as(nanotime("1970-01-11T00:00:00.000000000-00:00"), "POSIXct"), as.POSIXct("1970-01-10 19:00:00")) expect_identical(as(nanotime("1970-01-11T00:00:00.000000000-00:00"), "integer64"), as.integer64("864000000000000")) expect_identical(as(nanotime("1970-01-11T00:00:00.000000000-00:00"), "nanoduration"), as.nanoduration("240:00:00")) ## test nanotime sequences: ## straightforward with integer64 and nanoduration1 expect_identical(seq(as.nanotime(1), by=1e9, length.out=10), as.nanotime(seq(1, by=1e9, length.out=10))) expect_identical(seq(as.nanotime(1), by=1e9, along.with=1:10), as.nanotime(seq(1, by=1e9, length.out=10))) expect_identical(seq(from=as.nanotime(1), to=as.nanotime(10e9), by=1e9), as.nanotime(seq(1, 10e9, by=1e9))) expect_identical(seq(from=as.nanotime(1), to=as.nanotime(9e9+1), length.out=10), as.nanotime(seq(1, 10e9, by=1e9))) expect_identical(seq(as.nanotime(1), by=as.nanoduration(1e9), length.out=10), as.nanotime(seq(1, by=1e9, length.out=10))) expect_identical(seq(as.nanotime(1), as.nanotime(10e9), by=as.nanoduration(1e9)), as.nanotime(seq(1, 10e9, by=1e9))) ## increment with a period: expect_identical(seq(as.nanotime(0), by=as.nanoperiod("1m"), length.out=4, tz="UTC"), as.nanotime(c("1970-01-01T00:00:00+00:00", "1970-02-01T00:00:00+00:00", "1970-03-01T00:00:00+00:00", "1970-04-01T00:00:00+00:00"))) expect_identical(seq(as.nanotime(0), by=as.nanoperiod("1m"), length.out=0, tz="UTC"), nanotime()) expect_identical(seq(as.nanotime(0), to=as.nanotime("1970-04-01T00:00:00+00:00"), by=as.nanoperiod("1m"), tz="UTC"), as.nanotime(c("1970-01-01T00:00:00+00:00", "1970-02-01T00:00:00+00:00", "1970-03-01T00:00:00+00:00", "1970-04-01T00:00:00+00:00"))) ## other seq errors or warnings: expect_warning(seq(as.nanotime(1), by=1e9, length.out=10:12), "first element used of 'length.out' argument") expect_error(seq(as.nanotime(0), by=as.nanoperiod(c("1m","2m")), length.out=4, tz="UTC"), "'by' must be of length 1") expect_error(seq(as.nanotime(0), by=as.nanoperiod("1m"), length.out=-1, tz="UTC"), "'length.out' must be a non-negative number") expect_error(seq(from=as.nanotime(1)), "'seq.nanotime' cannot be called with only one argument") expect_error(seq(from=as.nanotime(1), to=as.nanotime(2), length.out=as.integer()), "argument 'length.out' must be of length 1") expect_error(seq(from=as.nanotime(1), length.out=1), "at least two of 'to', 'by', and 'length.out' or 'along.with' must be specified") expect_error(seq(from=as.nanotime(1), to=as.nanoduration(10e9), by=1e9), "'to' must be a 'nanotime'") expect_error(seq(from=as.nanotime(1:2), to=as.nanotime(1), by=1e9), "'from' must be of length 1") expect_error(seq(from=as.nanotime(1), to=as.nanotime(1:2), by=1e9), "'to' must be of length 1") expect_error(seq(from=as.nanotime(1), to=as.nanotime(2), by=1e9, length.out=1, too_much=2), "too many arguments") expect_error(seq(as.nanotime(1), by=c(1e9,2), length.out=10), "'by' must be of length 1") expect_error(seq(as.nanotime(1), to=as.nanotime(10), by=c(1e9,2)), "'by' must be of length 1") expect_error(seq(as.nanotime(1), by=as.nanoperiod("1d"), length.out=10), "'tz' is a mandatory argument for sequences with a 'period' step") expect_error(seq(as.nanotime(1), to=as.nanotime(10), by=as.nanoperiod("1d")), "'tz' is a mandatory argument for sequences with a 'period' step") ## test date time component access if (!isSolaris) { expect_identical(nano_wday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/New_York"), 6L) expect_identical(nano_wday(as.nanotime("2020-03-14 23:32:00 America/New_York"), "Europe/Paris"), 0L) expect_identical(nano_mday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/New_York"), 14L) expect_identical(nano_mday(as.nanotime("2020-03-14 23:32:00 America/New_York"), "Europe/Paris"), 15L) expect_identical(nano_month(as.nanotime("2020-12-31 23:32:00-04:00"), "America/New_York"), 12L) expect_identical(nano_month(as.nanotime("2020-12-31 23:32:00 America/New_York"), "Europe/Paris"), 1L) expect_identical(nano_year(as.nanotime("2020-12-31 23:32:00-04:00"), "America/New_York"), 2020L) expect_identical(nano_year(as.nanotime("2020-12-31 23:32:00 America/New_York"), "Europe/Paris"), 2021L) expect_identical(nano_year(nanotime(1:10), "America/New_York"), rep(1969L, 10)) expect_identical(nano_year(as.nanotime("1916-03-14 12:32:00-04:00"), "America/New_York"), 1916L) expect_error(nano_wday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/Nu_York"), "Cannot retrieve timezone") expect_error(nano_mday(as.nanotime("2020-03-14 23:32:00-04:00"), "America/Nu_York"), "Cannot retrieve timezone") expect_error(nano_month(as.nanotime("2020-03-14 23:32:00-04:00"), "America/Nu_York"), "Cannot retrieve timezone") expect_error(nano_year(as.nanotime("2020-03-14 23:32:00-04:00"), "America/Nu_York"), "Cannot retrieve timezone") } ## 0-length ops: ## ------------ ## constructor: expect_identical(nanotime(character(), character()), nanotime()) expect_identical(nanotime(character(), tz="America/New_York"), nanotime()) expect_identical(nanotime("2020-03-28 UTC", tz=character()), nanotime()) ## accessors/funcs expect_identical(nano_wday(nanotime(), tz=character()), integer()) expect_identical(nano_wday(nanotime(1), tz=character()), integer()) expect_identical(nano_wday(nanotime(), tz="America/New_York"), integer()) expect_identical(nano_mday(nanotime(), tz=character()), integer()) expect_identical(nano_mday(nanotime(1), tz=character()), integer()) expect_identical(nano_mday(nanotime(), tz="America/New_York"), integer()) expect_identical(nano_month(nanotime(), tz=character()), integer()) expect_identical(nano_month(nanotime(1), tz=character()), integer()) expect_identical(nano_month(nanotime(), tz="America/New_York"), integer()) expect_identical(nano_year(nanotime(), tz=character()), integer()) expect_identical(nano_year(nanotime(1), tz=character()), integer()) expect_identical(nano_year(nanotime(), tz="America/New_York"), integer()) ## rep expect_identical(rep(nanotime(1), 2), nanotime(rep(1,2))) expect_identical(rep(nanotime(1:2), each=2), nanotime(rep(1:2, each=2))) nanotime/inst/tinytest/test_zoo.R0000644000176200001440000000217013713516230016716 0ustar liggesusers library(nanotime) isSolaris <- Sys.info()[["sysname"]] == "SunOS" if (isSolaris) exit_file("Skipping tests on Solaris.") #test_zoo <- function() { suppressMessages(library(zoo)) set.seed(42) x <- 100 + cumsum(rnorm(10)) y <- 100 + cumsum(rnorm(10)) mat <- cbind(x, y) now <- nanotime("2017-02-06T03:36:10.626159000+00:00") z <- zoo(mat, now + 11*(0:9)) # inc. by 11 to more visible, 1 works too oldOptions <- getOption("nanotimeFormat") options(nanotimeFormat = "%Y-%m-%dT%H:%M:%E9S%Ez") indexCharacter <- format(index(z)) options(nanotimeFormat = oldOptions) expect_equal(indexCharacter, c("2017-02-06T03:36:10.626159000+00:00", "2017-02-06T03:36:10.626159011+00:00", "2017-02-06T03:36:10.626159022+00:00", "2017-02-06T03:36:10.626159033+00:00", "2017-02-06T03:36:10.626159044+00:00", "2017-02-06T03:36:10.626159055+00:00", "2017-02-06T03:36:10.626159066+00:00", "2017-02-06T03:36:10.626159077+00:00", "2017-02-06T03:36:10.626159088+00:00", "2017-02-06T03:36:10.626159099+00:00")) nanotime/inst/tinytest/test_xts.R0000644000176200001440000000721213713520520016724 0ustar liggesusers## .parseISO8601 . . ## align.time . . . . ## apply.monthly . . ## as.environment.xts ## as.xts . . . . . . ## as.xts.methods . . ## axTicksByTime . . ## CLASS . . . . . . ## - coredata.xts . . . ## diff.xts ## dimnames.xts . . . ## endpoints . . . . ## first . . . . . . ## firstof . . . . . ## indexClass . . . . ## indexTZ ## - index ## isOrdered . . . . ## make.index.unique ## merge.xts . . . . ## na.locf.xts . . . ## ndays . . . . . . ## period.apply . . . ## period.max . . . . ## period.min . . . . ## period.prod . . . ## period.sum . . . . ## periodicity . . . ## plot.xts . . . . . ## - rbind.xts ## sample_matrix . . ## split.xts . . . . ## timeBased . . . . ## timeBasedSeq . . . ## to.period . . . . ## xts . . . . . . . ## xtsAPI . . . . . . ## xtsAttributes . . ## xtsInternals . . . ## [.xts . . . . . . exit_file("Skip xts tests for now") library(nanotime) ## check for hypothetical future version with nanotime support .runTheseTests <- requireNamespace("xts", quietly=TRUE) && packageVersion("xts") >= "0.12.0" if (!.runTheseTests) exit_file("Skip this xts version") suppressMessages(library(xts)) i1 <- nanotime(Sys.time()) + as.integer64(1:10) a1 <- matrix(1:30, 10, 3) x1 <- xts(a1, i1) expect_equal(coredata(x1), a1) #test_coredata.xts <- function() { i1 <- nanotime(Sys.time()) + as.integer64(1:10) a1 <- matrix(1:30, 10, 3) x1 <- xts(a1, i1) expect_equal(coredata(x1), a1) #test_index.xts <- function() { i1 <- nanotime(Sys.time()) + as.integer64(1:10) a1 <- matrix(1:30, 10, 3) x1 <- xts(a1, i1) ## don't check attributes, as xts adds 'tzone' and 'tclass' expect_equal(index(x1), i1, check.attributes = FALSE) #test_rbind.xts <- function() { i1 <- nanotime(Sys.time()) + as.integer64(1:10) i2 <- nanotime(Sys.time()) + as.integer64(11:20) x1 <- xts(matrix(1:30, 10, 3), i1) x2 <- xts(matrix(1:30, 10, 3), i2) exp <- xts(rbind(matrix(1:30, 10, 3), matrix(1:30, 10, 3)), nanotime(c(i1,i2))) expect_equal(rbind(x1, x2), exp) #test_c.xts <- function() { i1 <- nanotime(Sys.time())+ as.integer64(1:10) i2 <- nanotime(Sys.time())+ as.integer64(11:20) x1 <- xts(matrix(1:30, 10, 3), i1) x2 <- xts(matrix(1:30, 10, 3), i2) exp <- xts(rbind(matrix(1:30, 10, 3), matrix(1:30, 10, 3)), nanotime(c(i1,i2))) expect_equal(c(x1, x2), exp) #test_cbind.xts <- function() { i1 <- nanotime(Sys.time())+ as.integer64(1:10) i2 <- nanotime(Sys.time())+ as.integer64(11:20) dimnames1 <-list(NULL, c("a1","b1","c1")) dimnames2 <-list(NULL, c("a2","b2","c2")) a1 <- matrix(1:30, 10, 3, dimnames=dimnames1) a2 <- matrix(1:30, 10, 3, dimnames=dimnames2) x1 <- xts(a1, i1) x2 <- xts(a2, i2) exp <- xts(rbind(cbind(a1, matrix(NA, 10, 3, dimnames=dimnames2)), cbind(matrix(NA, 10, 3, dimnames=dimnames1), a2)), nanotime(c(i1,i2))) expect_equal(cbind(x1, x2), exp) ## test_plot.xts <- function() ## { ## ## plot doesn't work properly ## data(sample_matrix) ## sample.xts <- as.xts(sample_matrix) ## x <- xts(coredata(sample.xts), nanotime(index(sample.xts))) ## plot(x[,"Close"]) ## } #test_dimnames.xts <- function() { dimnames1 <-list(NULL, c("a1","b1","c1")) i1 <- nanotime(Sys.time())+ as.integer64(1:10) a1 <- matrix(1:30, 10, 3, dimnames=dimnames1) x1 <- xts(a1, i1) expect_equal(dimnames(x1), dimnames1) #test_align.time <- function() { i1 <- nanotime(Sys.time()) + as.integer64(1e9*1:200) a1 <- matrix(1:600, 200, 3) x1 <- xts(a1, i1) xx1 <- xts(a1, as.POSIXct(i1)) expect_equal(align.time(x1, n=as.integer64(60*1e9)), a1) #test_endpoints.xts <- function() { data(sample_matrix) sample.xts <- as.xts(sample_matrix) x <- xts(coredata(sample.xts), nanotime(index(sample.xts))) expect_equal(endpoints(x), c(0, 30, 58, 89, 119, 150, 180)) nanotime/inst/tinytest/test_data.table.R0000644000176200001440000001033013713516255020112 0ustar liggesuserslibrary(nanotime) if (!requireNamespace("data.table", quietly=TRUE)) exit_file("Package 'data.table' missing") library(data.table) ## nanotime ##test_nanotime_data_table_constructor <- function() { ## simpler data.table, inserts 'formatted' set.seed(42) N <- 300 shine <- nanotime(Sys.time()) + cumsum(10*rpois(n=N+1, lambda=4)) rain <- nanotime(Sys.time()) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) newdf <- data.table(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanotime_data_table_rbind <- function() { t1 <- nanotime(1:10) d1 <- 1:10 t2 <- nanotime(11:20) d2 <- 11:20 df1 <- data.table(t = t1, d = d1) df2 <- data.table(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.table(t = c(t1, t2), d = c(d1, d2))) ##test_nanotime_data_table_cbind <- function() { t1 <- nanotime(1:10) d1 <- 1:10 t2 <- nanotime(11:20) d2 <- 11:20 df1 <- data.table(t1 = t1, d1 = d1) df2 <- data.table(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.table(t1 = t1, d1 = d1, t2=t2, d2=d2)) ## nanoduration ##test_nanoduration_data_table_constructor <- function() { ## simpler data.table, inserts 'formatted' set.seed(42) N <- 300 shine <- as.nanoduration(1000) + cumsum(10*rpois(n=N+1, lambda=4)) rain <- as.nanoduration(2000) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) newdf <- data.table(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanoduration_data_table_rbind <- function() { t1 <- as.nanoduration(1:10) d1 <- 1:10 t2 <- as.nanoduration(11:20) d2 <- 11:20 df1 <- data.table(t = t1, d = d1) df2 <- data.table(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.table(t = c(t1, t2), d = c(d1, d2))) ##test_nanoduration_data_table_cbind <- function() { t1 <- as.nanoduration(1:10) d1 <- 1:10 t2 <- as.nanoduration(11:20) d2 <- 11:20 df1 <- data.table(t1 = t1, d1 = d1) df2 <- data.table(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.table(t1 = t1, d1 = d1, t2=t2, d2=d2)) ## nanoperiod ##test_nanoperiod_data.table_constructor <- function() { ## simpler data.table, inserts 'formatted' set.seed(42) N <- 300 shine <- as.nanoperiod(1000) + cumsum(10*rpois(n=N+1, lambda=4)) rain <- as.nanoperiod(2000) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) newdf <- data.table(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanoperiod_data_table_rbind <- function() { t1 <- as.nanoperiod(1:10) d1 <- 1:10 t2 <- as.nanoperiod(11:20) d2 <- 11:20 df1 <- data.table(t = t1, d = d1) df2 <- data.table(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.table(t = c(t1, t2), d = c(d1, d2))) ##test_nanoperiod_data_table_cbind <- function() { t1 <- as.nanoperiod(1:10) d1 <- 1:10 t2 <- as.nanoperiod(11:20) d2 <- 11:20 df1 <- data.table(t1 = t1, d1 = d1) df2 <- data.table(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.table(t1 = t1, d1 = d1, t2=t2, d2=d2)) ## nanoival ##test_nanoival_data.table_constructor <- function() { ## simpler data.table, inserts 'formatted' set.seed(42) N <- 300 shine_start <- nanotime(1000) + cumsum(10*rpois(n=N+1, lambda=4)) shine_end <- shine_start + as.nanoduration("01:00:00") rain_start <- nanotime(2000) + cumsum(10*rpois(n=N+1, lambda=4) + round(runif(N+1)*25)) rain_end <- shine_end + as.nanoduration("02:00:00") shine <- nanoival(shine_start, shine_end) rain <- nanoival(rain_start, rain_end) newdf <- data.table(rain=rain, shine=shine) expect_identical(newdf$rain, rain) expect_identical(newdf$shine, shine) ##test_nanoival_data_table_rbind <- function() { t1 <- nanoival(nanotime(1:10), nanotime(2:11)) d1 <- 1:10 t2 <- nanoival(nanotime(11:20), nanotime(12:21)) d2 <- 11:20 df1 <- data.table(t = t1, d = d1) df2 <- data.table(t = t2, d = d2) df <- rbind(df1, df2) expect_identical(df, data.table(t = c(t1, t2), d = c(d1, d2))) ##test_nanoival_data_table_cbind <- function() { t1 <- nanoival(nanotime(1:10), nanotime(2:11)) d1 <- 1:10 t2 <- nanoival(nanotime(11:20), nanotime(12:21)) d2 <- 11:20 df1 <- data.table(t1 = t1, d1 = d1) df2 <- data.table(t2 = t2, d2 = d2) df <- cbind(df1, df2) expect_identical(df, data.table(t1 = t1, d1 = d1, t2=t2, d2=d2)) nanotime/inst/NEWS.Rd0000644000176200001440000001473714325354041014121 0ustar liggesusers\name{NEWS} \title{News for Package \pkg{nanotime}} \newcommand{\ghpr}{\href{https://github.com/eddelbuettel/nanotime/pull/#1}{##1}} \newcommand{\ghit}{\href{https://github.com/eddelbuettel/nanotime/issues/#1}{##1}} \section{Changes in version 0.3.7 (2022-10-23)}{ \itemize{ \item Update mkdocs for material docs generator (Dirk in \ghpr{102}) \item Use \code{inherits()} instead comparing to \code{class()} (Trevor Davis in \ghpr{104}) \item Set default arguments in \code{nanoduration()} (Trevor Davis in \ghpr{105}) \item Add \code{as.nanoduration.difftime()} support (Trevor Davis in \ghpr{106}) \item Add +/- methods for \code{nanotime} and \code{difftime} objects (Trevor Davis in \ghpr{110} closing \ghit{108}, \ghit{107}) } } \section{Changes in version 0.3.6 (2022-03-06)}{ \itemize{ \item Fix incorrect subsetting with operator \code{\%in\%} (Leonardo in \ghpr{100} fixing \ghit{99}). \item Fix incorrect parsing for negative nanoperiod (Leonardo in \ghpr{100} fixing \ghit{96}). \item Test for \code{class} via \code{inherits()} (Dirk). } } \section{Changes in version 0.3.5 (2021-12-14)}{ \itemize{ \item Applied patch by Tomas Kalibera for Windows UCRT under the upcoming R 4.2.0 expected for April. } } \section{Changes in version 0.3.4 (2021-11-24)}{ \itemize{ \item Added a few more \code{as.character} conversion function (Dirk) \item Expose \code{nanoperiod} functionality via header file for use by other packages (Leonardo in \ghpr{95} fixing \ghit{94}). } } \section{Changes in version 0.3.3 (2021-08-09)}{ \itemize{ \item New demo \code{ggplot2Example.R} (Leonardo and Dirk). \item New documentation website using mkdocs-material (Dirk). \item Updated unit test to account for r-devel POSIXct changes, and re-enable full testing under r-devel (Dirk). \item Additional \code{nanoduration} and \code{character} ops plus tests (Colin Umansky in \ghpr{88} addressing \ghit{87}). \item New \code{plus} and \code{minus} functions for periods (Leonardo in \ghpr{91}). } } \section{Changes in version 0.3.2 (2020-09-03)}{ \itemize{ \item Correct for big endian (Elliott Sales de Andrade in \ghpr{81}). \item Use the \code{RcppCCTZ_API.h} header (Dirk in \ghpr{82}). \item Conditionally reduce test coverage (Dirk in \ghpr{83}). } } \section{Changes in version 0.3.1 (2020-08-09)}{ \itemize{ \item Several small cleanups to ensure a more robust compilation (Leonardo and Dirk in \ghpr{75} fixing \ghit{74}). \item Show Solaris some extra love by skipping tests and examples with a timezone (Dirk in \ghpr{76}). } } \section{Changes in version 0.3.0 (2020-08-06)}{ \itemize{ \item Use \code{tzstr=} instead of \code{tz=} in call to \pkg{RcppCCTZ::parseDouble()}) (Matt Dowle in \ghpr{49}). \item Add new comparison operators for \code{nanotime} and \code{charcters} (Dirk in \ghpr{54} fixing \ghit{52}). \item Switch from \pkg{RUnit} to \pkg{tinytest} (Dirk in \ghpr{55}) \item Substantial functionality extension in with new types \code{nanoduration}, \code{nanoival} and \code{nanoperiod} (Leonardo in \ghpr{58}, \ghpr{60}, \ghpr{62}, \ghpr{63}, \ghpr{65}, \ghpr{67}, \ghpr{70} fixing \ghit{47}, \ghit{51}, \ghit{57}, \ghit{61}, \ghit{64} with assistance from Dirk). \item A new (yet still draft-ish) vignette was added describing the four core types (Leonardo and Dirk in \ghpr{71}). \item A required compilation flag for Windows was added (Leonardo in \ghpr{72}). \item \pkg{RcppCCTZ} function are called in new 'non-throwing' variants to not trigger exeception errors (Leonardo in \ghpr{73}). } } \section{Changes in version 0.2.4 (2019-05-25)}{ \itemize{ \item Define [[ method (Dirk in \ghpr{45} fixing \ghit{44}). } } \section{Changes in version 0.2.3 (2018-09-30)}{ \itemize{ \item Skip some tests on Solaris which seems borked with timezones. As we have no real access, no real fix possible (Dirk in \ghpr{42}). \item Update Travis setup } } \section{Changes in version 0.2.2 (2018-07-18)}{ \itemize{ \item Unit tests depending on future \CRANpkg{xts} behaviour remain disabled (Dirk in \ghpr{41}). } } \section{Changes in version 0.2.1 (2018-07-01)}{ \itemize{ \item Added attribute-preserving comparison (Leonardo in \ghpr{33}). \item Added two \code{integer64} casts in constructors (Dirk in \ghpr{36}). \item Added two checks for empty arguments (Dirk in \ghpr{37}). } } \section{Changes in version 0.2.0 (2017-06-22)}{ \itemize{ \item Rewritten in S4 to provide more robust operations (\ghpr{17} by Leonardo) \item Ensure \code{tz=""} is treated as unset (Leonardo in \ghpr{20}) \item Added \code{format} and \code{tz} arguments to \code{nanotime}, \code{format}, \code{print} (\ghpr{22} by Leonardo and Dirk) \item Ensure printing respect \code{options()$max.print}, ensure names are kept with vector (\ghpr{23} by Leonardo) \item Correct \code{summary()} by defining \code{names<-} (Leonardo in \ghpr{25} fixing \ghit{24}) \item Report error on operations that are meaningful for type; handled NA, NaN, Inf, -Inf correctly (Leonardo in \ghpr{27} fixing \ghit{26}) } } \section{Changes in version 0.1.2 (2017-03-27)}{ \itemize{ \item The \code{as.integer64} function is now exported as well. } } \section{Changes in version 0.1.1 (2017-02-04)}{ \itemize{ \item The default display format now always shows nine digits (\ghpr{10} closing \ghpr{9}) \item The default print method was updated to use formated output, and a new new converter \code{as.integer64} was added \item Several 'Ops' method are now explicitly defined allowing casting of results (rather than falling back on bit64 behaviour) \item The format routine is now more careful about not loosing precision (\ghit{13} closing \ghit{12}) } } \section{Changes in version 0.1.0 (2017-01-10)}{ \itemize{ \item Added Windows support thanks to expanded \CRANpkg{RcppCCTZ} (closes \ghit{6}) \item Added "mocked up" demo with nanosecond delay networking analysis \item Added 'fmt' and 'tz' options to output functions, expanded \code{format.nanotime} (closing \ghit{2} and \ghit{3}) \item Added data.frame support \item Expanded tests } } \section{Changes in version 0.0.1 (2016-12-15)}{ \itemize{ \item Initial CRAN upload. \item Package is functional and provides examples. } } nanotime/cleanup0000755000176200001440000000012114325355664013450 0ustar liggesusers#!/bin/sh rm -fr src/*.o src/*.so src/*.dll src/*.dylib *~ */*~ vignettes/auto/