.packageName <- "BsMD"
"BsProb" <-
function (X, y, blk = 0, mFac = 3, mInt = 2, p = 0.25, g = 2, 
    ng = 1, nMod = 10) 
{
    X <- as.matrix(X)
    y <- unlist(y)
    if (length(y) != nrow(X)) 
        stop("X and y should have same number of observations")
    if (blk == 0) {
        ifelse(is.null(colnames(X)), faclab <- paste("F", seq(ncol(X)), 
            sep = ""), faclab <- colnames(X))
        colnames(X) <- faclab
    }
    else {
        if (is.null(colnames(X))) {
            faclab <- paste("F", seq(ncol(X) - blk), sep = "")
            blklab <- paste("B", seq(blk), sep = "")
            colnames(X) <- c(blklab, faclab)
        }
        else {
            faclab <- colnames(X)[-seq(blk)]
            blklab <- colnames(X)[seq(blk)]
        }
    }
    rownames(X) <- rownames(X, do.NULL = FALSE, prefix = "r")
    storage.mode(X) <- "double"
    Y <- as.double(y)
    N <- as.integer(nrow(X))
    COLS <- as.integer(ncol(X) - blk)
    BLKS <- as.integer(blk)
    MXFAC <- as.integer(max(1, mFac))
    MXINT <- as.integer(mInt)
    PI <- as.double(p)
    if (length(g) == 1) {
        INDGAM <- as.integer(0)
        GAMMA <- as.double(g)
        NGAM <- as.integer(1)
        INDG2 <- as.integer(0)
        GAM2 <- as.double(0)
    }
    else {
        if (ng == 1) {
            INDGAM <- as.integer(0)
            GAMMA <- as.double(c(g[1], g[2]))
            NGAM <- as.integer(1)
            INDG2 <- as.integer(1)
            GAM2 <- as.double(g[2])
        }
        else {
            INDGAM <- as.integer(1)
            GAMMA <- as.double(seq(min(g), max(g), length = ng))
            NGAM <- as.integer(ng)
            INDG2 <- as.integer(0)
            GAM2 <- as.double(0)
        }
    }
    NTOP <- as.integer(nMod)
    mdcnt <- as.integer(0)
    ptop <- as.double(rep(0, NTOP))
    sigtop <- as.double(rep(0, NTOP))
    nftop <- as.integer(rep(0, NTOP))
    jtop <- matrix(0, nrow = NTOP, ncol = MXFAC)
    dimnames(jtop) <- list(paste("M", seq(NTOP), sep = ""), paste("x", 
        seq(MXFAC), sep = ""))
    storage.mode(jtop) <- "integer"
    del <- as.double(0)
    sprob <- as.double(rep(0, (COLS + 1)))
    names(sprob) <- c("none", faclab)
    pgam <- as.double(rep(0, NGAM))
    prob <- matrix(0, nrow = (1 + COLS), ncol = NGAM)
    dimnames(prob) <- list(c("none", paste("x", 1:COLS, sep = "")), 
        seq(NGAM))
    storage.mode(prob) <- "double"
    ind <- as.integer(-1)
    lst <- .Fortran("bm", X, Y, N, COLS, BLKS, MXFAC, MXINT, 
        PI, INDGAM, INDG2, GAM2, NGAM, GAMMA, NTOP, mdcnt, ptop, 
        sigtop, nftop, jtop, del, sprob, pgam, prob, ind, PACKAGE = "BsMD")
    names(lst) <- c("X", "Y", "N", "COLS", "BLKS", "MXFAC", "MXINT", 
        "PI", "INDGAM", "INDG2", "GAM2", "NGAM", "GAMMA", "NTOP", 
        "mdcnt", "ptop", "sigtop", "nftop", "jtop", "del", "sprob", 
        "pgam", "prob", "ind")
    invisible(structure(lst, class = c("BsProb", class(lst))))
}
"DanielPlot" <-
function (fit, code = FALSE, faclab = NULL, block = FALSE, datax = TRUE, 
    half = FALSE, pch = "*", cex.fac = par("cex.lab"), cex.lab = par("cex.lab"), 
    cex.pch = par("cex.axis"), ...) 
{
    if (any(names(coef(fit)) == "(Intercept)")) {
        factor.effects <- 2 * coef(fit)[-1]
    }
    else {
        factor.effects <- 2 * coef(fit)
    }
    names(factor.effects) <- attr(fit$terms, "term.labels")
    factor.effects <- factor.effects[!is.na(factor.effects)]
    if (half) {
        tn <- data.frame(x = qnorm(0.5 * ((rank(abs(factor.effects)) - 
            0.5)/length(factor.effects) + 1)), x = abs(factor.effects))
        names(tn$x) <- names(factor.effects)
        xlab <- "half-normal score"
        ylab <- "absolute effects"
    }
    else {
        tn <- qqnorm(factor.effects, plot = FALSE)
        xlab <- "normal score"
        ylab <- "effects"
    }
    if (datax) {
        tmp <- tn$x
        tn$x <- tn$y
        tn$y <- tmp
        tmp <- xlab
        xlab <- ylab
        ylab <- tmp
    }
    labx <- names(factor.effects)
    laby <- 1:length(tn$y)
    points.labels <- names(factor.effects)
    plot.default(tn, xlim = c(min(tn$x), max(tn$x) + diff(range(tn$x))/5), 
        pch = pch, xlab = xlab, ylab = ylab, cex.lab = cex.lab, 
        ...)
    if (is.null(faclab)) {
        if (!code) {
            effect.code <- labx
        }
        else {
            terms.ord <- attr(fit$terms, "order")
            max.order <- max(terms.ord)
            no.factors <- length(terms.ord[terms.ord == 1])
            factor.label <- attr(fit$terms, "term.labels")[1:no.factors]
            factor.code <- LETTERS[1:no.factors]
            if (block) 
                factor.code <- c("BK", factor.code)
            texto <- paste(factor.code[1], "=", factor.label[1])
            for (i in 2:no.factors) {
                texto <- paste(texto, ", ", factor.code[i], "=", 
                  factor.label[i])
            }
            mtext(side = 1, line = 2.5, texto, cex = cex.fac)
            get.sep <- function(string, max.order) {
                k <- max.order - 1
                get.sep <- rep(0, k)
                j <- 1
                for (i in 1:nchar(string)) {
                  if (substring(string, i, i) == ":") {
                    get.sep[j] <- i
                    if (j == k) 
                      break
                    j <- j + 1
                  }
                }
                get.sep
            }
            labeling <- function(string, get.sep, max.order, 
                factor.code, factor.label) {
                labeling <- ""
                sep <- get.sep(string, max.order)
                sep <- sep[sep > 0]
                n <- length(sep) + 1
                if (n > 1) {
                  sep <- c(0, sep, nchar(string) + 1)
                  for (i in 1:n) {
                    labeling <- paste(labeling, sep = "", factor.code[factor.label == 
                      substring(string, sep[i] + 1, sep[i + 1] - 
                        1)][1])
                  }
                }
                else labeling <- paste(labeling, sep = "", factor.code[factor.label == 
                  string][1])
                labeling
            }
            effect.code <- rep("", length(terms.ord))
            for (i in 1:length(terms.ord)) {
                effect.code[i] <- labeling(names(tn$x)[i], get.sep, 
                  max.order, factor.code, factor.label)
            }
        }
        text(tn, paste("   ", effect.code), cex = cex.pch, adj = 0, 
            xpd = NA)
    }
    else {
        if (!is.list(faclab)) 
            stop("* Argument 'faclab' has to be NULL or a list with idx and lab objects")
        text(tn$x[faclab$idx], tn$y[faclab$idx], labels = faclab$lab, 
            cex = cex.fac, adj = 0)
    }
    invisible(cbind(as.data.frame(tn), no = 1:length(tn$x)))
}
"LenthPlot" <-
function (obj, alpha = 0.05, plt = TRUE, limits = TRUE, xlab = "factors", 
    ylab = "effects", faclab = NULL, cex.fac = par("cex.lab"), 
    cex.axis = par("cex.axis"), adj = 1, ...) 
{
    if (class(obj) == "lm") {
        i <- pmatch("(Intercept)", names(coef(obj)))
        if (!is.na(i)) 
            obj <- 2 * coef(obj)[-pmatch("(Intercept)", names(coef(obj)))]
    }
    b <- obj
    if (!is.null(faclab)) {
        if (!is.list(faclab)) 
            stop("* Argument 'faclab' has to be NULL or a list with 'idx' and 'lab' elements")
        names(b) <- rep("", length(b))
        names(b)[faclab$idx] <- faclab$lab
    }
    m <- length(b)
    d <- m/3
    s0 <- 1.5 * median(abs(b))
    cj <- as.numeric(b[abs(b) < 2.5 * s0])
    PSE <- 1.5 * median(abs(cj))
    ME <- qt(1 - alpha/2, d) * PSE
    gamma <- (1 + (1 - alpha)^(1/m))/2
    SME <- qt(gamma, d) * PSE
    if (plt) {
        n <- length(b)
        x <- seq(n)
        ylim <- range(c(b, 1.2 * c(ME, -ME)))
        plot(x, b, xlim = c(1, n + 1), ylim = ylim, type = "n", 
            xlab = xlab, ylab = ylab, frame = FALSE, axes = FALSE, 
            ...)
        idx <- x[names(b) != ""]
        text(x[idx], rep(par("usr")[3], length(idx)), labels = names(b)[idx], 
            cex = cex.fac, xpd = NA)
        axis(2, cex.axis = cex.axis)
        for (i in seq(along = x)) segments(x[i], 0, x[i], b[i], 
            lwd = 3, col = 1, lty = 1)
        abline(h = 0, lty = 4, xpd = FALSE)
        if (limits) {
            abline(h = ME * c(1, -1), xpd = FALSE, lty = 2, col = grey(0.2))
            text(adj * (n + 1) * c(1, 1), (ME + strheight("M", 
                cex = cex.axis)) * c(1, -1), labels = "ME", cex = 0.9 * 
                cex.axis, xpd = FALSE)
            abline(h = SME * c(1, -1), xpd = FALSE, lty = 3, 
                col = grey(0.2))
            text(adj * (n + 1) * c(1, 1), (SME + strheight("M", 
                cex = cex.axis)) * c(1, -1), labels = "SME", 
                cex = 0.9 * cex.axis, xpd = FALSE)
        }
    }
    return(c(alpha = alpha, PSE = PSE, ME = ME, SME = SME))
}
"MD" <-
function (X, y, nFac, nBlk = 0, mInt = 3, g = 2, nMod, p, s2, 
    nf, facs, nFDes = 4, Xcand, mIter = 20, nStart = 5, startDes = NULL, 
    top = 20, eps = 1e-05) 
{
    if (nFac + nBlk != ncol(X)) 
        stop("nFac + nBlk != ncol(X)")
    if (nFac + nBlk != ncol(Xcand)) 
        stop("nFac + nBlk != ncol(Xcand)")
    if (ncol(Xcand) != ncol(X)) 
        stop("ncol(Xcand) != ncol(X)")
    ITMAX <- as.integer(mIter)
    N0 <- as.integer(nrow(X))
    NRUNS <- as.integer(nFDes)
    N <- as.integer(nrow(Xcand))
    X <- as.matrix(X)
    storage.mode(X) <- "double"
    Y <- as.double(y)
    GAMMA <- as.double(g[1])
    GAM2 <- as.double(0)
    if (length(g) > 1) 
        GAM2 <- as.double(g[2])
    COLS <- as.integer(nFac)
    BL <- as.integer(nBlk)
    CUT <- as.integer(mInt)
    GAMMA <- as.double(g[1])
    if (length(g) == 1) {
        IND <- as.integer(0)
    }
    else {
        IND <- as.integer(1)
        GAM2 <- as.double(g[2])
    }
    Xcand <- as.matrix(Xcand)
    storage.mode(Xcand) <- "double"
    NM <- as.integer(nMod)
    P <- as.double(as.numeric(p))
    SIGMA2 <- as.double(as.numeric(s2))
    NF <- as.integer(as.numeric(nf))
    MNF <- as.integer(max(NF))
    JFAC <- as.matrix(facs)
    storage.mode(JFAC) <- "integer"
    if (is.null(startDes)) {
        if (is.null(nStart)) 
            stop("nStart needed when startDes is NULL")
        INITDES <- as.integer(1)
        NSTART <- as.integer(nStart)
        MBEST <- matrix(0, nrow = NSTART, ncol = NRUNS)
        storage.mode(MBEST) <- "integer"
    }
    else {
        INITDES <- as.integer(0)
        startDes <- as.matrix(startDes)
        NSTART <- as.integer(nrow(startDes))
        if (ncol(startDes) != NRUNS) 
            stop("ncol(startDes) should be nFDes")
        MBEST <- as.matrix(startDes)
        storage.mode(MBEST) <- "integer"
    }
    NTOP <- as.integer(top)
    TOPD <- as.double(rep(0, NTOP))
    TOPDES <- matrix(0, nrow = NTOP, ncol = NRUNS)
    dimnames(TOPDES) <- list(seq(top), paste("r", seq(NRUNS), 
        sep = ""))
    storage.mode(TOPDES) <- "integer"
    EPS <- as.double(eps)
    flag <- as.integer(-1)
    lst <- .Fortran("md", NSTART, NRUNS, ITMAX, INITDES, N0, 
        IND, X, Y, GAMMA, GAM2, BL, COLS, N, Xcand, NM, P, SIGMA2, 
        NF, MNF, JFAC, CUT, MBEST, NTOP, TOPD, TOPDES, EPS, flag, 
        PACKAGE = "BsMD")
    names(lst) <- c("NSTART", "NRUNS", "ITMAX", "INITDES", "N0", 
        "IND", "X", "Y", "GAMMA", "GAM2", "BL", "COLS", "N", 
        "Xcand", "NM", "P", "SIGMA2", "NF", "MNF", "JFAC", "CUT", 
        "MBEST", "NTOP", "TOPD", "TOPDES", "EPS", "flag")
    invisible(structure(lst, class = c("MD", class(lst))))
}
"plot.BsProb" <-
function (x, code = TRUE, prt = FALSE, cex.axis = par("cex.axis"), 
    ...) 
{
    spikes <- function(prob, lwd = 3, ...) {
        y <- prob
        n <- nrow(y)
        x <- seq(n)
        lab <- rownames(prob)
        plot(x, y[, 1], xlim = range(x), ylim = c(0, 1), type = "n", 
            xlab = "factors", ylab = "posterior probability", 
            frame = FALSE, axes = FALSE, ...)
        if (ncol(y) == 1) {
            for (i in x) segments(x[i], 0, x[i], y[i, 1], lwd = lwd, 
                col = grey(0.2))
        }
        else {
            y[, 1] <- apply(prob, 1, min)
            y[, 2] <- apply(prob, 1, max)
            for (i in x) {
                segments(x[i], 0, x[i], y[i, 2], lwd = lwd, col = grey(0.8), 
                  lty = 1)
                segments(x[i], 0, x[i], y[i, 1], lwd = lwd, col = grey(0.2), 
                  lty = 1)
            }
        }
        axis(1, at = x, labels = lab, line = 0, cex.axis = cex.axis)
        axis(2, cex.axis = cex.axis)
        invisible(NULL)
    }
    if (!any(class(x) == "BsProb")) 
        return("\nArgument `x' should be class BsProb. Output of corresponding function.")
    ifelse(x$INDGAM == 0, prob <- as.matrix(x$sprob), prob <- x$prob)
    if (code) 
        rownames(prob) <- rownames(x$prob)
    else rownames(prob) <- names(x$sprob)
    spikes(prob, ...)
    if (prt) 
        summary.BsProb(x)
    invisible(NULL)
}
"print.BsProb" <-
function (x, X = TRUE, resp = TRUE, factors = TRUE, models = TRUE, 
    nMod = 10, digits = 3, plt = FALSE, verbose = FALSE, ...) 
{
    if (verbose) {
        print(unclass(x))
        return(invisible(NULL))
    }
    nFac <- ncol(x$X) - x$blk
    if (X) {
        cat("\n Design Matrix:\n")
        print(round(x$X, digits))
    }
    if (resp) {
        cat("\n Response vector:\n")
        cat(round(x$Y, digits = digits), fill = 80)
    }
    cat("\n Calculations:\n")
    if (x$INDGAM == 0) {
        if (x$INDG2 == 0) {
            calc <- c(x$N, x$COLS, x$BLKS, x$MXFAC, x$MXINT, 
                x$P, x$GAMMA, x$mdcnt)
            names(calc) <- c("nRun", "nFac", "nBlk", "mFac", 
                "mInt", "p", "g", "totMod")
        }
        else {
            calc <- c(x$N, x$COLS, x$BLKS, x$MXFAC, x$MXINT, 
                x$P, x$GAMMA[1], x$GAMMA[2], x$mdcnt)
            names(calc) <- c("nRun", "nFac", "nBlk", "mFac", 
                "mInt", "p", "g[main]", "g[int]", "totMod")
        }
    }
    else {
        calc <- c(x$N, x$COLS, x$BLKS, x$MXFAC, x$MXINT, x$P, 
            x$GAMMA[1], x$GAMMA[x$NGAM], x$mdcnt)
        names(calc) <- c("nRun", "nFac", "nBlk", "mFac", "mInt", 
            "p", "g[1]", paste("g[", x$NGAM, "]", sep = ""), 
            "totMod")
    }
    out.list <- list(calc = calc)
    print(round(calc, digits = digits))
    if (plt) 
        plot.BsProb(x, code = TRUE)
    cat("\n Output file: BsPrint.out\n")
    if (factors) {
        if (x$INDGAM == 1) 
            cat("\n Weighted factor probabilities:\n")
        else cat("\n Factor probabilities:\n")
        prob <- data.frame(Factor = names(x$sprob), Code = rownames(x$prob), 
            Prob = round(x$sprob, digits), row.names = seq(length(x$sprob)))
        print(prob, digits = digits)
        out.list[["probabilities"]] <- prob
    }
    if (x$INDGAM == 0 & models) {
        cat("\n Model probabilities:\n")
        ind <- seq(min(nMod, x$NTOP))
        Prob <- round(x$ptop, digits)
        NumFac <- x$nftop
        Sigma2 <- round(x$sigtop, digits)
        Factors <- apply(x$jtop, 1, function(x) ifelse(all(x == 
            0), "none", paste(x[x != 0], collapse = ",")))
        dd <- data.frame(Prob, Sigma2, NumFac, Factors)[ind, 
            ]
        print(dd, digits = digits, right = FALSE)
        out.list[["models"]] <- dd
    }
    if (x$INDGAM == 1) {
        cat("\n Values of posterior density of gamma:\n")
        dd <- data.frame(gamma = x$GAMMA, pgam = x$pgam)
        out.list[["gamma.density"]] <- dd
        print(dd, digits = digits)
        cat("\n Posterior probabilities for each gamma value:\n")
        print(dd <- round(rbind(gamma = x$GAMMA, x$prob), digits = digits))
        out.list[["probabilities"]] <- dd
    }
    invisible(out.list)
}
"print.MD" <-
function (x, X = FALSE, resp = FALSE, Xcand = TRUE, models = TRUE, 
    nMod = x$nMod, digits = 3, verbose = FALSE, ...) 
{
    if (verbose) {
        print(unclass(x))
        return(invisible(NULL))
    }
    nFac <- ncol(x$X) - x$blk
    if (X) {
        cat("\n Design Matrix:\n")
        print(x$X)
    }
    if (resp) {
        cat("\n Response vector:\n")
        cat(round(x$Y, digits = digits), fill = 80)
    }
    cat("\n Base:\n")
    calc <- c(x$N0, x$COLS, x$BL, x$CUT, x$GAMMA, x$GAM2, x$NM)
    names(calc) <- c("nRuns", "nFac", "nBlk", "maxInt", "gMain", 
        "gInter", "nMod")
    print(calc)
    cat("\n Follow up:\n")
    out <- c(x$N, x$NRUNS, x$ITMAX, x$NSTART)
    names(out) <- c("nCand", "nRuns", "maxIter", "nStart")
    print(out)
    calc <- c(calc, out)
    out.list <- list(calc = calc)
    if (models && x$NM > 0) {
        cat("\n Competing Models:\n")
        ind <- seq(x$NM)
        Prob <- round(x$P, digits)
        NumFac <- x$NF
        Sigma2 <- round(x$SIGMA2, digits)
        Factors <- apply(x$JFAC, 1, function(x) ifelse(all(x == 
            0), "none", paste(x[x != 0], collapse = ",")))
        dd <- data.frame(Prob, Sigma2, NumFac, Factors)
        print(dd, digits = digits, right = FALSE)
        out.list[["models"]] <- dd
    }
    if (Xcand) {
        cat("\n Candidate runs:\n")
        print(round(x$Xcand, digits))
    }
    cat("\n Search trace output file: MDPrint.out\n")
    if (any(x$D <= 0)) 
        ind <- min(which(x$D <= 0))
    else ind <- x$NTOP
    toprun <- data.frame(D = x$TOPD, x$TOPDES)
    ind <- min(nMod, ind)
    cat("\n   Top", ind, "runs:\n")
    print(dd <- round(toprun[seq(ind), ], digits))
    out.list[["follow.up"]] <- dd
    invisible(out.list)
}
"summary.BsProb" <-
function (object, nMod = 10, digits = 3, ...) 
{
    nFac <- ncol(object$X) - object$blk
    cat("\n Calculations:\n")
    if (object$INDGAM == 0) {
        if (object$INDG2 == 0) {
            calc <- c(object$N, object$COLS, object$BLKS, object$MXFAC, 
                object$MXINT, object$P, object$GAMMA, object$mdcnt)
            names(calc) <- c("nRun", "nFac", "nBlk", "mFac", 
                "mInt", "p", "g", "totMod")
        }
        else {
            calc <- c(object$N, object$COLS, object$BLKS, object$MXFAC, 
                object$MXINT, object$P, object$GAMMA[1], object$GAMMA[2], 
                object$mdcnt)
            names(calc) <- c("nRun", "nFac", "nBlk", "mFac", 
                "mInt", "p", "g[main]", "g[int]", "totMod")
        }
    }
    else {
        calc <- c(object$N, object$COLS, object$BLKS, object$MXFAC, 
            object$MXINT, object$P, object$GAMMA[1], object$GAMMA[object$NGAM], 
            object$mdcnt)
        names(calc) <- c("nRun", "nFac", "nBlk", "mFac", "mInt", 
            "p", "g[1]", paste("g[", object$NGAM, "]", sep = ""), 
            "totMod")
    }
    out.list <- list(calc = calc)
    print(round(calc, digits = digits))
    prob <- data.frame(Factor = names(object$sprob), Code = rownames(object$prob), 
        Prob = round(object$sprob, digits), row.names = seq(length(object$sprob)))
    if (object$INDGAM == 0) {
        cat("\n Factor probabilities:\n")
        print(prob, digits = digits)
        cat("\n Model probabilities:\n")
        ind <- seq(min(nMod, object$NTOP))
        Prob <- round(object$ptop, digits)
        NumFac <- object$nftop
        Sigma2 <- round(object$sigtop, digits)
        Factors <- apply(object$jtop, 1, function(x) ifelse(all(x == 
            0), "none", paste(x[x != 0], collapse = ",")))
        dd <- data.frame(Prob, Sigma2, NumFac, Factors)[ind, 
            ]
        print(dd, digits = digits, right = FALSE)
        out.list[["probabilities"]] <- prob
        out.list[["models"]] <- dd
    }
    if (object$INDGAM == 1) {
        cat("\n Posterior probabilities for each gamma value:\n")
        print(dd <- round(rbind(gamma = object$GAMMA, object$prob), 
            digits = digits))
        out.list[["probabilities"]] <- dd
    }
    invisible(out.list)
}
"summary.MD" <-
function (object, digits = 3, verbose = FALSE, ...) 
{
    if (verbose) {
        print(unclass(object))
        return(invisible(NULL))
    }
    nFac <- ncol(object$X) - object$blk
    cat("\n Base:\n")
    calc <- c(object$N0, object$COLS, object$BL, object$CUT, 
        object$GAMMA, object$GAM2, object$NM)
    names(calc) <- c("nRuns", "nFac", "nBlk", "maxInt", "gMain", 
        "gInter", "nMod")
    print(calc)
    cat("\n Follow up:\n")
    out <- c(object$N, object$NRUNS, object$ITMAX, object$NSTART)
    names(out) <- c("nCand", "nRuns", "maxIter", "nStart")
    print(out)
    calc <- c(calc, out)
    out.list <- list(calc = calc)
    if (any(object$D <= 0)) 
        ind <- min(which(object$D <= 0))
    else ind <- object$NTOP
    toprun <- data.frame(D = object$TOPD, object$TOPDES)
    ind <- min(10, ind)
    cat("\n   Top", ind, "runs:\n")
    print(dd <- round(toprun[seq(ind), ], digits))
    out.list[["follow.up"]] <- dd
    invisible(out.list)
}
