	.file	"62638085.c"
	.intel_syntax noprefix
	.text
	.section	.rodata
	.align 8
.LC0:
	.ascii	"## server file\nserver <- function(input, output, session) {"
	.ascii	"\n  ## limit for the input file size\n  options(shiny.maxReq"
	.ascii	"uestSize=30*1024^2) \n  ## to store the current selection\n "
	.ascii	" selection <- renderText({\n    return(unlist(get_selected(i"
	.ascii	"nput$taskSelection)))\n  })\n  \n  ## to store the error enc"
	.ascii	"ountered\n  error <- renderText({\n    if (is.null(inputFile"
	.ascii	"$dataPaths))\n      error <- c('No model file loaded !!')\n "
	.ascii	"   else if (is.null(inputFile$modelData))\n      error <- c("
	.ascii	"'Please load a valid model file!!')\n    else if (exists('me"
	.ascii	"ssage', where=resTask()))\n      error <- c(resTask()$messag"
	.ascii	"e)\n    else\n      error <- ''\n    \n    return(error)\n  "
	.ascii	"})\n  \n  ## to display the error \n  output$errorOut <- ren"
	.ascii	"derText({\n    textOutput('error')\n    return(error())\n  }"
	.ascii	")\n  \n  ## To store the information of input model\n  input"
	.ascii	"File <- reactiveValues()\n  observe({\n    \n    inputFile$f"
	.ascii	"ileNames <- dir('copasi')\n    inputFile$dataPaths <- paste0"
	.ascii	"('copasi/',inputFile$fileNames)\n    \n    inputFile$dirName"
	.ascii	" <- dirname(inputFile$dataPaths)\n    inputFile$modelData <-"
	.ascii	" NULL\n    inputFile$rootnode <- NULL\n    inputFile$modelLo"
	.ascii	"aded <- FALSE\n    for (i in 1:length(inputFile$fileNames)){"
	.ascii	"\n      inputFileName <- inputFile$fileNames[i]\n      if (g"
	.ascii	"repl('\\\\.cps$',inputFileName)){\n        inputFile$modelDa"
	.ascii	"ta <- CoRC::loadModel(inputFile$dataPaths[i])\n        input"
	.ascii	"File$modelName <- inputFileName\n        inputFile$rootnode "
	.ascii	"<- xmlTreeParse(inputFile$dataPaths[i])\n        inputFile$m"
	.ascii	"odelAttrs <- xmlAttrs(inputFile$rootnode$doc$children$COPASI"
	.ascii	"[names(inputFile$rootnode$doc$children$COPASI)=='Model']$Mod"
	.ascii	"el)\n        inputFile$modelLoaded <- TRUE\n      }\n    }\n"
	.ascii	"    \n    if (is.null(inputFile$modelData)){\n      return(e"
	.ascii	"rror())\n    }\n\n    inputFile$compartments <- CoRC::getCom"
	.ascii	"partments(model=inputFile$modelData)\n    inputFile$species "
	.ascii	"<- CoRC::getSpecies(model=inputFile$modelData)\n    inputFil"
	.ascii	"e$reactions <- CoRC::getReactions(model=inputFile$modelData)"
	.ascii	"\n    inputFile$globalQuantities <- CoRC::getGlobalQuantitie"
	.ascii	"s(model=inputFile$mo"
	.ascii	"delData)\n    inputFile$events <- CoRC::getEvents(model=inpu"
	.ascii	"tFile$modelData)\n    inputFile$parameters <- CoRC::getParam"
	.ascii	"eters(model=inputFile$modelData)\n    inputFile$stoichiometr"
	.ascii	"y <- CoRC::getStoichiometryMatrix(model=inputFile$modelData)"
	.ascii	"\n    inputFile$linkMatrix <- CoRC::getLinkMatrix(model=inpu"
	.ascii	"tFile$modelData)\n    inputFile$settingsTC <- CoRC::getTC(mo"
	.ascii	"del=inputFile$modelData)\n    inputFile$settingsOpt <- CoRC:"
	.ascii	":getOpt(model=inputFile$modelData)\n    inputFile$settingsPE"
	.ascii	" <- CoRC::getPE(model=inputFile$modelData)\n    inputFile$ta"
	.ascii	"skList <- c('Compartments', 'Species', 'Reactions'\n        "
	.ascii	"                    ,'Global Quantities', 'Events', 'Paramet"
	.ascii	"ers'\n                            ,'Stoichiometry','Steady S"
	.ascii	"tate','Time Course'\n                            ,'Metabolic"
	.ascii	" Control Analysis','Optimization'\n                         "
	.ascii	"   ,'Parameter Estimation', 'Linear Noise Approximation')\n "
	.ascii	" })\n  \n  \n  ## Theme functions for the plots\n  theme_pm "
	.ascii	"<- function () {\n    theme_bw(base_size=12) + #base_family="
	.ascii	"'Arial Black'\n      theme(panel.grid=element_line(linetype="
	.ascii	"'dashed', color='light grey', size=0.2),axis.ticks.length=un"
	.ascii	"it(-0.15, 'cm'),axis.text.x = element_text(margin=unit(c(0.2"
	.ascii	"5,0.25,0.25,0.25),'cm')),axis.text.y = element_text(margin=u"
	.ascii	"nit(c(0.25,0.25,0.25,0.25),'cm')))\n  }\n  \n  output$modelI"
	.ascii	"nfo <- renderText({\n    if (is.null(inputFile$modelData))\n"
	.ascii	"      return()\n    selectedTask = selection()\n    strOut= "
	.ascii	"paste('<h1>','Model Name:', inputFile$modelAttrs[[2]],'</h1>"
	.ascii	"')\n    if (selectedTask %in% inputFile$taskList ){\n      i"
	.ascii	"f (selectedTask == 'Parameter Estimation' ){\n        expfil"
	.ascii	"eName= ''\n        valfileName= ''\n        if (xmlSize(inpu"
	.ascii	"tFile$rootnode$doc$children$COPASI[names(inputFile$rootnode$"
	.ascii	"doc$children$COPASI)=='ListOfTasks']$ListOfTasks[[6]][[2]][["
	.ascii	"9]]) >= 1){\n          xmlList= xmlChildren(inputFile$rootno"
	.ascii	"de$doc$children$COPASI[names(inputFile$rootnode$doc$children"
	.ascii	"$COPASI)=='ListOfTasks']$ListOfTasks[[6]][[2]][[9]][[1]])\n "
	.ascii	"         for (i in 1:xmlSize(xmlList)){\n            p"
	.ascii	"aramValue= xmlToList(xmlList[[i]])\n            if (paramVal"
	.ascii	"ue[[1]] == 'File Name'){\n              expfileName= paramVa"
	.ascii	"lue[[3]]\n              break\n            }\n          }\n "
	.ascii	"         if (expfileName %in% inputFile$fileNames){\n       "
	.ascii	"     #file.copy(inputFile$dataPaths[inputFile$fileNames == e"
	.ascii	"xpfileName], paste0(inputFile$dirName,'/',expfileName), over"
	.ascii	"write = TRUE, recursive = FALSE,copy.mode = TRUE, copy.date "
	.ascii	"= FALSE)\n          }\n          else\n            expfileNa"
	.ascii	"me= paste(' <font color=','red','>  Please load a valid data"
	.ascii	" file along with the model. File name: <b>', expfileName ,'<"
	.ascii	"/b> </font> ')\n        }\n          \n        if (xmlSize(i"
	.ascii	"nputFile$rootnode$doc$children$COPASI[names(inputFile$rootno"
	.ascii	"de$doc$children$COPASI)=='ListOfTasks']$ListOfTasks[[6]][[2]"
	.ascii	"][[10]]) > 2){\n          xmlList= xmlChildren(inputFile$roo"
	.ascii	"tnode$doc$children$COPASI[names(inputFile$rootnode$doc$child"
	.ascii	"ren$COPASI)=='ListOfTasks']$ListOfTasks[[6]][[2]][[10]][[1]]"
	.ascii	")\n          for (i in 1:xmlSize(xmlList)){\n            par"
	.ascii	"amValue= xmlToList(xmlList[[i]])\n            if (paramValue"
	.ascii	"[[1]] == 'File Name'){\n              valfileName= paramValu"
	.ascii	"e[[3]]\n              break\n            }\n          }\n   "
	.ascii	"       if (valfileName %in% inputFile$fileNames){\n         "
	.ascii	"   #file.copy(inputFile$dataPaths[inputFile$fileNames == val"
	.ascii	"fileName], paste0(inputFile$dirName,'/',valfileName), overwr"
	.ascii	"ite = TRUE, recursive = FALSE,copy.mode = TRUE, copy.date = "
	.ascii	"FALSE)\n          }\n          else\n            valfileName"
	.ascii	"= paste(' <font color=','red','>  Please load a valid data f"
	.ascii	"ile along with the model. File name: <b>', valfileName ,'</b"
	.ascii	"> </font> ')\n        }\n        strOut= paste(strOut, '<h2>"
	.ascii	"',selectedTask,'</h2>')\n        strOut= paste(strOut, '<pre"
	.ascii	"><b> Experimental Data: </b>',expfileName,'<br> <br>')\n    "
	.ascii	"    strOut= paste(strOut, '<b>Validation Data: </b>',valfile"
	.ascii	"Name,'<br>')\n        strOut= paste(strOut, '<pre><b> Random"
	.ascii	"ize Start Values: </b>',inputFile$settingsPE$randomize_start"
	.ascii	"_values)\n        strOut= paste(strOut, '<b>  Calcul"
	.ascii	"ate Statistics: </b>',inputFile$settingsPE$calculate_statist"
	.ascii	"ics, '</pre></pre>')\n      }\n      else if (selectedTask ="
	.ascii	"= 'Optimization' ){\n        strOut= paste(strOut, '<h2>',se"
	.ascii	"lectedTask,'</h2>')\n        strOut= paste(strOut, '<pre><b>"
	.ascii	" Expression: </b>',inputFile$settingsOpt$expression)\n      "
	.ascii	"  strOut= paste(strOut, '<pre><b> Maxmize: </b>',inputFile$s"
	.ascii	"ettingsOpt$maximize, '</pre>')\n        strOut= paste(strOut"
	.ascii	", '<b>Subtask: </b>',inputFile$settingsOpt$subtask)\n       "
	.ascii	" strOut= paste(strOut, '<pre><b> Randomize Start Values: </b"
	.ascii	">',inputFile$settingsOpt$randomize_start_values)\n        st"
	.ascii	"rOut= paste(strOut, '<b>  Calculate Statistics: </b>',inputF"
	.ascii	"ile$settingsOpt$calculate_statistics, '</pre></pre>')\n     "
	.ascii	" }\n      else\n        strOut= paste(strOut, '<h2>',selecte"
	.ascii	"dTask,'</h2>')\n    }\n    else if (selectedTask == 'Model' "
	.ascii	"|| inputFile$modelLoaded == T){\n      strOut= paste('<pre><"
	.ascii	"b> Model: </b>',inputFile$modelAttrs[[2]],'<br>')\n      str"
	.ascii	"Out= paste(strOut,'<pre><table><tr><th>Time Unit:</th><td>',"
	.ascii	"inputFile$modelAttrs[[4]]\n                    ,'</td><th>Vo"
	.ascii	"lume Unit:</th><td>',inputFile$modelAttrs[[5]],'</td></tr>')"
	.ascii	"\n      strOut= paste(strOut,'<tr><th>Quantity Unit:</th><td"
	.ascii	">',inputFile$modelAttrs[[8]]\n                    ,'</td><th"
	.ascii	">Area Unit:</th><td>',inputFile$modelAttrs[[6]],'</td></tr>'"
	.ascii	")\n      strOut= paste(strOut,'<tr><th>Avogadro Constant:</t"
	.ascii	"h><td>',inputFile$modelAttrs[[10]]\n                    ,'</"
	.ascii	"td><th>Length Unit:</th><td>',inputFile$modelAttrs[[7]],'</t"
	.ascii	"d></tr></table></pre></pre>')\n      }\n    return(strOut)\n"
	.ascii	"  })\n  \n  output$selectedMethod<- renderText({\n    if (is"
	.ascii	".null(inputFile$rootnode))\n      return()\n    \n    select"
	.ascii	"edTask = selection()\n    if (selectedTask == 'Parameter Est"
	.ascii	"imation' ){\n      methodSetting= inputFile$settingsPE$metho"
	.ascii	"d\n    }\n    else if(selectedTask == 'Optimization' ){\n   "
	.ascii	"   methodSetting= inputFile$settingsOpt$method\n    }\n    e"
	.ascii	"lse{\n      return()\n    }\n  \n    strOut= ''\n    namesMe"
	.ascii	"thod= paste0(toupper(substring(names(methodSetting),1,1)),su"
	.ascii	"b"
	.ascii	"string(names(methodSetting),2))\n    strOut= paste('<pre><b>"
	.ascii	"',namesMethod[[1]],'</b>:',methodSetting[[1]],'<br><pre>')\n"
	.ascii	"    for (i in 2:length(namesMethod)){\n      strOut= paste(s"
	.ascii	"trOut, '<b>',namesMethod[[i]],'</b>:&nbsp ', methodSetting[["
	.ascii	"i]], '<br>')\n    }\n    return(paste(strOut,'</pre></pre>')"
	.ascii	")\n  })\n    \n  paramList <- function () {\n    if (is.null"
	.ascii	"(inputFile$rootnode))\n      return()\n    \n    selectedTas"
	.ascii	"k = selection()\n    if (selectedTask == 'Parameter Estimati"
	.ascii	"on' ){\n      xmlList= inputFile$rootnode$doc$children$COPAS"
	.ascii	"I[names(inputFile$rootnode$doc$children$COPASI)=='ListOfTask"
	.ascii	"s']$ListOfTasks[[6]][[2]][[4]]\n    }\n    else if(selectedT"
	.ascii	"ask == 'Optimization' ){\n      xmlList= inputFile$rootnode$"
	.ascii	"doc$children$COPASI[names(inputFile$rootnode$doc$children$CO"
	.ascii	"PASI)=='ListOfTasks']$ListOfTasks[[5]][[2]][[6]]\n    }\n   "
	.ascii	" else{\n      return()\n    }\n    \n    numParameters= xmlS"
	.ascii	"ize(xmlChildren(xmlList))\n    if (numParameters < 1)\n     "
	.ascii	" return()\n    resTable <- setNames(data.frame(matrix(ncol ="
	.ascii	" 4, nrow = numParameters)), c('LowerBound', 'Parameter', 'Up"
	.ascii	"perBound','StartValue'))\n    for (i in 1:numParameters){\n "
	.ascii	"     xmlListIN <- xmlChildren(xmlList[[i]])\n      for (j in"
	.ascii	" 1:xmlSize(xmlListIN)){\n        checkParam = names(xmlListI"
	.ascii	"N) == 'Parameter'\n        if (checkParam[j]){\n          pa"
	.ascii	"ramValue= xmlToList(xmlListIN[[j]])\n          if (paramValu"
	.ascii	"e[[1]] == 'LowerBound'){\n            resTable$LowerBound[i]"
	.ascii	" = paramValue[[3]]\n          }\n          else if (paramVal"
	.ascii	"ue[[1]]== 'ObjectCN'){\n            resTable$Parameter[i] = "
	.ascii	"gsub(',Reference=','.',gsub('.*Vector=','',paramValue[[3]]))"
	.ascii	"\n          }\n          else if (paramValue[[1]]== 'UpperBo"
	.ascii	"und'){\n            resTable$UpperBound[i] = paramValue[[3]]"
	.ascii	"\n          }\n          else if (paramValue[[1]]== 'StartVa"
	.ascii	"lue'){\n            resTable$StartValue[i] = paramValue[[3]]"
	.ascii	"\n          }}}}\n    return(resTable)\n  }\n  \n  constrLis"
	.ascii	"t <- function () {\n    if (is.null(inputFile$rootnode))\n  "
	.ascii	"    return()\n    \n    selectedTask = selection()\n    if ("
	.ascii	"selectedTask "
	.ascii	"== 'Parameter Estimation' ){\n      xmlList= inputFile$rootn"
	.ascii	"ode$doc$children$COPASI[names(inputFile$rootnode$doc$childre"
	.ascii	"n$COPASI)=='ListOfTasks']$ListOfTasks[[6]][[2]][[5]]\n    }\n"
	.ascii	"    else if(selectedTask == 'Optimization' ){\n      xmlList"
	.ascii	"= inputFile$rootnode$doc$children$COPASI[names(inputFile$roo"
	.ascii	"tnode$doc$children$COPASI)=='ListOfTasks']$ListOfTasks[[5]]["
	.ascii	"[2]][[7]]\n    }\n    else{\n      return()\n    }\n\n    nu"
	.ascii	"mParameters= xmlSize(xmlChildren(xmlList))\n    if (numParam"
	.ascii	"eters < 1)\n      return()\n    resTable <- setNames(data.fr"
	.ascii	"ame(matrix(ncol = 3, nrow = numParameters)), c('LowerBound',"
	.ascii	" 'Parameter', 'UpperBound'))\n    \n    for (i in 1:numParam"
	.ascii	"eters){\n      xmlListIN <- xmlChildren(xmlList[[i]])\n     "
	.ascii	" for (j in 1:xmlSize(xmlListIN)){\n        checkParam = name"
	.ascii	"s(xmlListIN) == 'Parameter'\n        if (checkParam[j]){\n  "
	.ascii	"        paramValue= xmlToList(xmlListIN[[j]])\n          if "
	.ascii	"(paramValue[[1]] == 'LowerBound'){\n            resTable$Low"
	.ascii	"erBound[i] = paramValue[[3]]\n          }\n          else if"
	.ascii	" (paramValue[[1]]== 'ObjectCN'){\n            resTable$Param"
	.ascii	"eter[i] = gsub(',Reference=','.',gsub('.*Vector=','',paramVa"
	.ascii	"lue[[3]]))\n          }\n          else if (paramValue[[1]]="
	.ascii	"= 'UpperBound'){\n            resTable$UpperBound[i] = param"
	.ascii	"Value[[3]]\n            }}}}\n    return(resTable)\n  }\n  \n"
	.ascii	"\n#### To execute different tasks ####\n  resTask <- eventRe"
	.ascii	"active(input$runTask, {\n    modelData <- inputFile$modelDat"
	.ascii	"a\n    selectedTask <- selection()\n    \n    progress <- sh"
	.ascii	"iny::Progress$new() # Create a Progress object\n    on.exit("
	.ascii	"progress$close()) # To make sure it closes when we exit this"
	.ascii	" reactive, even if there's an error\n    progress$set(messag"
	.ascii	"e = paste('Running ', selectedTask), value = 0)\n\n    if (s"
	.ascii	"electedTask %in% c('Steady State','Linear Noise Approximatio"
	.ascii	"n')){\n      if (selectedTask == 'Steady State') settingTask"
	.ascii	" = CoRC::getSS(model=modelData)\n      else settingTask = Co"
	.ascii	"RC::getLNA(model=modelData)\n      settingTask$method$resolu"
	.ascii	"tion = input$resolution\n      settingTask$method$derivation"
	.ascii	"_fact"
	.ascii	"or = input$derivationFac\n      settingTask$method$use_newto"
	.ascii	"n = input$useNewton\n      settingTask$method$use_integratio"
	.ascii	"n = input$useIntegration\n      settingTask$method$use_back_"
	.ascii	"integration = input$useBackIntegration\n      if (selectedTa"
	.ascii	"sk == 'Steady State') resTask <- tryCatch(CoRC::runSS(calcul"
	.ascii	"ate_jacobian = input$calculateJacobian,perform_stability_ana"
	.ascii	"lysis =input$performStabilityAnalysis,method=settingTask$met"
	.ascii	"hod,model=modelData), warning = function(warning_condition){"
	.ascii	"return(warning_condition) }, error = function(error_conditio"
	.ascii	"n){return(error_condition) })\n      if (selectedTask == 'Li"
	.ascii	"near Noise Approximation') resTask <- tryCatch(CoRC::runLNA("
	.ascii	"perform_steady_state_analysis = input$lnaSelection,method=se"
	.ascii	"ttingTask$method,model=modelData), warning = function(warnin"
	.ascii	"g_condition){return(warning_condition) }, error = function(e"
	.ascii	"rror_condition){return(error_condition) })\n    }\n    else "
	.ascii	"if (selectedTask == 'Time Course'){\n      resTask <- tryCat"
	.ascii	"ch(CoRC::runTC(duration=input$obsTime,dt=input$obsIntervalSi"
	.ascii	"ze,start_in_steady_state=input$startSteady,method=input$time"
	.ascii	"CourseSelection,model=modelData,save_result_in_memory = T), "
	.ascii	"warning = function(warning_condition){return(warning_conditi"
	.ascii	"on) }, error = function(error_condition){return(error_condit"
	.ascii	"ion) })\n    }\n    else if(selectedTask == 'Metabolic Contr"
	.ascii	"ol Analysis'){\n      settingTask = CoRC::getMCA(model=model"
	.ascii	"Data)\n      settingTask$method$modulation_factor = input$mo"
	.ascii	"dulationFactor\n      settingTask$method$use_reder = input$u"
	.ascii	"seReder\n      settingTask$method$use_smallbone = input$useS"
	.ascii	"mallbone\n      resTask <- tryCatch(CoRC::runMCA(perform_ste"
	.ascii	"ady_state_analysis = input$mcaSelection, method= settingTask"
	.ascii	"$method, model=modelData), warning = function(warning_condit"
	.ascii	"ion){return(warning_condition) }, error = function(error_con"
	.ascii	"dition){return(error_condition) })\n    }\n    else if (sele"
	.ascii	"ctedTask == 'Optimization'){\n      resTask <- tryCatch(CoRC"
	.ascii	"::runOptimization(model=modelData), warning = function(warni"
	.ascii	"ng_condition){return(warning_condition"
	.ascii	") }, error = function(error_condition){return(error_conditio"
	.ascii	"n) })\n    }\n    else if (selectedTask == 'Parameter Estima"
	.ascii	"tion'){\n      resTask <- tryCatch(CoRC::runParameterEstimat"
	.ascii	"ion(model=modelData), warning = function(warning_condition){"
	.ascii	"return(warning_condition) }, error = function(error_conditio"
	.ascii	"n){return(error_condition) })\n    }\n    else\n      resTas"
	.ascii	"k <- 'No Task found'\n\n    return(resTask)\n  })\n  \n#### "
	.ascii	"To download tables for different tasks ####  \n  ## For data"
	.ascii	" download\n  output$downloadData<-downloadHandler(\n    file"
	.ascii	"name = function() { \n      if (is.null(inputFile$dataPaths)"
	.ascii	")\n        return(NULL)\n      paste(sub('\\\\..*$', '',inpu"
	.ascii	"tFile$modelName) , '.csv', sep='')\n      },\n    content = "
	.ascii	"function(file) {\n      if (is.null(file) || error() != '' |"
	.ascii	"| is.null(resTask()))\n        return(NULL)\n      selectedT"
	.ascii	"ask <- selection()\n      if (selectedTask == 'Steady State'"
	.ascii	"){\n        writeData <- resTask()$species[,c('name','concen"
	.ascii	"tration','rate','transition_time')]\n      }\n      else if "
	.ascii	"(selectedTask == 'Time Course' && 'Time' %in% names(resTask("
	.ascii	")$result) && !is.null(input$columns)){\n        writeData <-"
	.ascii	" resTask()$result[, c('Time',input$columns), drop = FALSE]\n"
	.ascii	"      }\n      else if(selectedTask == 'Metabolic Control An"
	.ascii	"alysis'){\n        writeData <- resTask()$elasticities_unsca"
	.ascii	"led\n      }\n      else  if(selectedTask == 'Optimization')"
	.ascii	"{\n        writeData <- resTask()$parameters\n      }\n     "
	.ascii	" else if(selectedTask == 'Parameter Estimation'){\n        w"
	.ascii	"riteData <- resTask()$parameter\n      }\n      else if (sel"
	.ascii	"ectedTask == 'Linear Noise Approximation'){\n        writeDa"
	.ascii	"ta <- resTask()$covariance_matrix\n      }\n      else\n    "
	.ascii	"    writeData <- 'No Data found'\n      \n      write.csv(wr"
	.ascii	"iteData,file)\n    }\n  )\n  \n  ## For model download\n  ou"
	.ascii	"tput$downloadModel<-downloadHandler(\n    filename = functio"
	.ascii	"n() { \n      if (is.null(inputFile$dataPaths))\n        ret"
	.ascii	"urn(NULL)\n      paste(sub('\\\\..*$', '',inputFile$modelNam"
	.ascii	"e) , '.zip', sep='')\n    },\n    content = function(file) {"
	.ascii	"\n      zipr(file,in"
	.ascii	"putFile$dataPaths)\n    },\n    contentType = 'application/z"
	.ascii	"ip'\n  )\n  \n#### To render output tables for different tas"
	.ascii	"ks ####\n  \n  ## Output task-specific results\n  output$tab"
	.ascii	"leResults1 <- DT::renderDataTable({\n    if (error() != '' |"
	.ascii	"| is.null(resTask()))\n      return(NULL)\n    \n    selecte"
	.ascii	"dTask <- selection()\n    if (selectedTask == 'Steady State'"
	.ascii	"){\n      return(resTask()$species[,c('name','concentration'"
	.ascii	",'rate','transition_time')])\n    }\n    else if (selectedTa"
	.ascii	"sk == 'Time Course' && 'Time' %in% names(resTask()$result) &"
	.ascii	"& !is.null(input$columns)){\n      return(resTask()$result[,"
	.ascii	" c('Time',input$columns), drop = FALSE])\n    }\n    else if"
	.ascii	"(selectedTask == 'Metabolic Control Analysis'){\n      retur"
	.ascii	"n(resTask()$elasticities_unscaled)\n    }\n    else if(selec"
	.ascii	"tedTask %in% c('Optimization','Parameter Estimation') && !is"
	.ascii	".null(resTask()$main)){\n      data <- t(as.data.frame(resTa"
	.ascii	"sk()$main))\n      colnames(data) <- c('Value')\n      retur"
	.ascii	"n(data)\n    }\n    else\n      return(NULL)\n    },options "
	.ascii	"= list(scrollX = TRUE, scrollY = '400px'))\n  \n  \n  output"
	.ascii	"$tableResults2 <- DT::renderDataTable({\n    if (error() != "
	.ascii	"'' || is.null(resTask()))\n      return(NULL)\n    \n    sel"
	.ascii	"ectedTask <- selection()\n    if (selectedTask == 'Steady St"
	.ascii	"ate'){\n      colNames <- colnames(resTask()$jacobian_comple"
	.ascii	"te)\n      data <- data.frame(resTask()$jacobian_complete)\n"
	.ascii	"      data <- formattable(data, list(area(col = colnames(dat"
	.ascii	"a)) ~ color_tile('lightpink', 'lightgreen')))\n      colname"
	.ascii	"s(data) <- colNames\n      return(as.datatable(data,options "
	.ascii	"= list(scrollX = TRUE, scrollY = '400px')))\n    }\n    else"
	.ascii	" if(selectedTask == 'Metabolic Control Analysis'){\n      re"
	.ascii	"turn(resTask()$elasticities_unscaled)\n    }\n    else if(se"
	.ascii	"lectedTask == 'Optimization'){\n      return(resTask()$param"
	.ascii	"eters)\n    }\n    else if(selectedTask == 'Parameter Estima"
	.ascii	"tion'){\n      return(resTask()$parameter)\n    }\n    else "
	.ascii	"if(selectedTask == 'Linear Noise Approximation'){\n\t   colN"
	.ascii	"ames <- colnames(resTask()$covariance_matrix)\n      data <-"
	.ascii	" data.frame(resT"
	.ascii	"ask()$covariance_matrix)\n      data <- formattable(data, li"
	.ascii	"st(area(col = colnames(data)) ~ color_tile('lightpink', 'lig"
	.ascii	"htgreen')))\n      colnames(data) <- colNames\n      return("
	.ascii	"as.datatable(data,options = list(scrollX = TRUE, scrollY = '"
	.ascii	"400px')))\n    }\n    else\n      return(NULL)\n  })\n  \n  "
	.ascii	"output$tablePEexp <- DT::renderDataTable({\n    if (error() "
	.ascii	"!= '' || is.null(resTask()))\n      return(NULL)\n    return"
	.ascii	"(resTask()$experiments)\n  },options = list(scrollX = TRUE, "
	.ascii	"scrollY = '400px'))\n  \n  \n  ## Display the selected param"
	.ascii	"eters and constraints \n  output$tableParameterList <- DT::r"
	.ascii	"enderDataTable({\n    if(!is.null(paramList())) return(param"
	.ascii	"List())\n  },options = list(scrollX = TRUE, scrollY = '200px"
	.ascii	"'))\n  \n  output$tableConstraintList <- DT::renderDataTable"
	.ascii	"({\n    if (!is.null(constrList())) return(constrList())\n  "
	.ascii	"},options = list(scrollX = TRUE, scrollY = '200px'))\n  \n  "
	.ascii	"## Display information of the loaded model\n  output$tableMo"
	.ascii	"del <- DT::renderDataTable({\n    if (is.null(inputFile$mode"
	.ascii	"lData))\n      return()\n    selectedTask <- selection()\n  "
	.ascii	"  tableModel <-  data.frame()\n    if (selectedTask == 'Comp"
	.ascii	"artments'){\n      tableModel <- inputFile$compartments\n   "
	.ascii	"   if (!is.null(tableModel)){\n        tableModel <- tableMo"
	.ascii	"del[,c(-1)]    \n      }}\n    else if (selectedTask == 'Spe"
	.ascii	"cies'){\n      tableModel <- inputFile$species\n      tableM"
	.ascii	"odel <- tableModel[,c(-1,-7,-9,-11)]\n    }\n    else if (se"
	.ascii	"lectedTask == 'Reactions'){\n      tableModel <- inputFile$r"
	.ascii	"eactions\n      if (!is.null(tableModel)){\n        tableMod"
	.ascii	"el <- tableModel[,c('name','reaction','rate_law','flux')]\n "
	.ascii	"       tableModel$rate_law <- gsub('.*\\\\[|\\\\]', '', tabl"
	.ascii	"eModel$rate_law)        \n      }}\n    else if (selectedTas"
	.ascii	"k == 'Global Quantities'){\n      tableModel <- inputFile$gl"
	.ascii	"obalQuantities\n      tableModel <- tableModel[,-1]\n    } \n"
	.ascii	"    else if (selectedTask == 'Events'){\n      tableModel <-"
	.ascii	" data.frame(inputFile$events)\n      if (!is.null(tableModel"
	.ascii	")){\n        tableModel <- tableModel[,-1]\n        tableMod"
	.ascii	"el$assignment_tar"
	.ascii	"get <- gsub('.*\\\\(|\\\\)', '', tableModel$assignment_targe"
	.ascii	"t)\n        tableModel$assignment_expression <- gsub('.*\\\\"
	.ascii	"(|\\\\)', '', tableModel$assignment_expression)\n      }} \n"
	.ascii	"    else if (selectedTask == 'Parameters'){\n      tableMode"
	.ascii	"l <- inputFile$parameters\n      if (!is.null(tableModel)){\n"
	.ascii	"        tableModel <- tableModel[,-1]\n        tableModel$ma"
	.ascii	"pping <- gsub('.*\\\\[|\\\\]', '', tableModel$mapping)  \n  "
	.ascii	"    }}\n    return(tableModel)\n  },options = list(scrollX ="
	.ascii	" TRUE, scrollY = '400px'))\n  \n  output$tableLM <- DT::rend"
	.ascii	"erDataTable({\n    if (is.null(inputFile$modelData))\n      "
	.ascii	"return()\n    colNames <- colnames(inputFile$linkMatrix)\n  "
	.ascii	"  data <- data.frame(inputFile$linkMatrix)\n    data <- form"
	.ascii	"attable(data, list(area(col = colnames(data)) ~ color_tile('"
	.ascii	"lightpink', 'lightgreen')))\n    colnames(data) <- colNames\n"
	.ascii	"    return(as.datatable(data,options = list(scrollX = TRUE, "
	.ascii	"scrollY = '400px')))\n  })\n  output$tableStoich <- DT::rend"
	.ascii	"erDataTable({\n    if (is.null(inputFile$modelData))\n      "
	.ascii	"return()\n    colNames <- colnames(inputFile$stoichiometry)\n"
	.ascii	"    data <- data.frame(inputFile$stoichiometry)\n    data <-"
	.ascii	" formattable(data, list(area(col = colnames(data)) ~ color_t"
	.ascii	"ile('lightpink', 'lightgreen')))\n    colnames(data) <- colN"
	.ascii	"ames\n    return(as.datatable(data,options = list(scrollX = "
	.ascii	"TRUE, scrollY = '400px')))\n  })\n\n#### To render UI and pl"
	.ascii	"ots for different tasks ####\n  output$plotOverview <- rende"
	.ascii	"rPlot({\n    selectedTask <- selection()\n    if (selectedTa"
	.ascii	"sk == 'Species'){\n      tableSpecies <- inputFile$species\n"
	.ascii	"      if (!is.null(tableSpecies) && nrow(tableSpecies) !=0 )"
	.ascii	"{\n        ylabel <- paste('Concentration (',tableSpecies$un"
	.ascii	"it[1], ')')\n        barplot(tableSpecies$initial_concentrat"
	.ascii	"ion, main='Species overview',  ylab=ylabel, names.arg=tableS"
	.ascii	"pecies$name, cex.names=0.8,las=2)\n      }\n    }\n    else "
	.ascii	"if (selectedTask == 'Global Quantities'){\n      tableGlobal"
	.ascii	"Quantities <- inputFile$globalQuantities\n      if (!is.null"
	.ascii	"(tableGlobalQuantities) && nrow(tableGlobalQuantities) !=0 )"
	.ascii	"{\n        ba"
	.ascii	"rplot(tableGlobalQuantities$initial_value, main='Global Quan"
	.ascii	"tities overview', ylab= 'Initial value', names.arg=tableGlob"
	.ascii	"alQuantities$name, cex.names=0.8,las=2)\n      }\n    }\n   "
	.ascii	" else if (selectedTask == 'Parameters'){\n      tableParamet"
	.ascii	"ers <- inputFile$parameters\n      if (!is.null(tableParamet"
	.ascii	"ers) && nrow(tableParameters) !=0 && !all(is.na(tableParamet"
	.ascii	"ers$value))){\n        barplot(tableParameters$value, main='"
	.ascii	"Parameters overview', ylab='Value', names.arg=tableParameter"
	.ascii	"s$name, cex.names=0.8,las=2)\n      }\n    }\n  })\n  \n  ou"
	.ascii	"tput$plotTC <- renderPlot({\n    if (error() != '' || is.nul"
	.ascii	"l(resTask()) || is.null(input$columns))\n      return(NULL)\n"
	.ascii	"    \n    selectedTask <- selection()\n    data <- resTask()"
	.ascii	"$result\n    if (selectedTask == 'Time Course' && 'Time' %in"
	.ascii	"% names(data)){\n      data <- data[, c('Time',input$columns"
	.ascii	"), drop = FALSE]\n      melted <- melt(data,id.vars='Time')\n"
	.ascii	"      colnames(melted)[2:3] <- c('Species', 'Number')\n     "
	.ascii	" plot <- ggplot(melted, aes(x=Time, y=Number, group=Species,"
	.ascii	" color= Species)) + geom_line(size = 1) + theme_classic(base"
	.ascii	"_size = 18) + ggtitle('Time-course of selected species') + y"
	.ascii	"lab('Concentration') + xlab('Time (s)') + theme_pm()\n      "
	.ascii	"print(plot)\n    }\n    else{\n      textOutput('error')\n  "
	.ascii	"  }\n  })\n\n  ## To load the output UI showing table/Plot\n"
	.ascii	"  output$show_output<- renderUI({\n    selectedTask <- selec"
	.ascii	"tion()\n    if (is.null(inputFile$modelData))\n      return("
	.ascii	"NULL)\n    if (selectedTask %in% c('Species','Global Quantit"
	.ascii	"ies','Parameters')){\n      tabsetPanel(id = 'mdl',tabPanel("
	.ascii	"'Table',DT::dataTableOutput('tableModel')),tabPanel('Overvie"
	.ascii	"w', plotOutput('plotOverview')))\n    }\n    else if (select"
	.ascii	"edTask %in% c('Reactions','Compartments', 'Events')){\n     "
	.ascii	"   tabPanel('mdlTable',DT::dataTableOutput('tableModel'))\n "
	.ascii	"   }\n    else if(selectedTask == 'Stoichiometry'){\n      t"
	.ascii	"absetPanel(id = 'mdlTable',tabPanel('Stoichiometry Matrix',D"
	.ascii	"T::dataTableOutput('tableStoich')),tabPanel('Link Matrix',DT"
	.ascii	"::dataTableOutput('tableLM')))\n    }\n    else if (selected"
	.ascii	"T"
	.ascii	"ask == 'Time Course'){\n      tabsetPanel(id = 'TC',tabPanel"
	.ascii	"('Time Course',DT::dataTableOutput('tableResults1')),tabPane"
	.ascii	"l('Plot', plotOutput('plotTC')))\n    }\n    else if (select"
	.ascii	"edTask == 'Steady State'){\n      tabsetPanel(id = 'SS',tabP"
	.ascii	"anel('Steady State', DT::dataTableOutput('tableResults1')),t"
	.ascii	"abPanel('Jacobian', DT::dataTableOutput('tableResults2')))\n"
	.ascii	"    }\n    else if(selectedTask == 'Metabolic Control Analys"
	.ascii	"is'){\n      tabPanel('Table',DT::dataTableOutput('tableResu"
	.ascii	"lts1'))\n    }\n    else if(selectedTask == 'Optimization'){"
	.ascii	"\n      tabsetPanel(id = 'PE',tabPanel('Main',DT::dataTableO"
	.ascii	"utput('tableResults1')),tabPanel('Optimized Parameters',DT::"
	.ascii	"dataTableOutput('tableResults2')))\n    }\n    else if(selec"
	.ascii	"tedTask == 'Parameter Estimation'){\n      tabsetPanel(id = "
	.ascii	"'PE',tabPanel('Main',DT::dataTableOutput('tableResults1')),t"
	.ascii	"abPanel('Fitted Parameters',DT::dataTableOutput('tableResult"
	.ascii	"s2')),tabPanel('Experiments', DT::dataTableOutput('tablePEex"
	.ascii	"p')))\n    }\n    else if(selectedTask == 'Linear Noise Appr"
	.ascii	"oximation'){\n      tabPanel('Table',DT::dataTableOutput('ta"
	.ascii	"bleResults2'))\n    }\n    else{\n    }\n  })\n  output$SSms"
	.ascii	"g <- renderText({\n    selectedTask <- selection()\n    resS"
	.ascii	"tr =ifelse(selectedTask == 'Steady State' && !is.null(resTas"
	.ascii	"k()$result),resTask()$result,ifelse(!is.null(resTask()$resul"
	.ascii	"t_ss),resTask()$result_ss,return(NULL)))\n    if(resStr == '"
	.ascii	"found') return('<pre> <b> Steady state found !!</b></pre>')\n"
	.ascii	"    else if(resStr == 'foundEquilibrium') return('<pre> <b> "
	.ascii	"Equilibrium steady state found!!</b></pre>')\n    else retur"
	.ascii	"n('<pre> <b> No steady state found !!</b></pre>')\n  })\n  \n"
	.ascii	"#### To choose species for table and plot output ** ONLY FOR"
	.ascii	" TIME_COURSE ** ####\n  output$choose_columns <- renderUI({\n"
	.ascii	"    # If missing input, return to avoid error later in funct"
	.ascii	"ion\n    if(error() != '' || is.null(resTask()))\n      retu"
	.ascii	"rn(NULL)\n    selectedTask <- selection()\n    output = tagL"
	.ascii	"ist()\n    if (selectedTask %in% c('Steady State','Linear No"
	.ascii	"ise Approximation')){\n      output[[1]] =  htmlOutput"
	.ascii	"('SSmsg')\n    }\n    else if (selectedTask == 'Time Course'"
	.ascii	" && 'Time' %in% names(resTask()$result)){\n      data <- res"
	.ascii	"Task()$result\n      # Get the data set with the appropriate"
	.ascii	" name\n      melted <- melt(data,id.vars='Time')\n      coln"
	.ascii	"ames(melted)[2:3] <- c('Species', 'Number')\n      colnames "
	.ascii	"<- unique(melted$Species)\n      output[[1]] = actionButton("
	.ascii	"'showAll', 'Show/Hide All')\n      # Create the checkboxes a"
	.ascii	"nd select them all by default\n      output[[2]] = checkboxG"
	.ascii	"roupInput('columns', '', choices  = colnames, selected = col"
	.ascii	"names, inline = T)\n    }\n    return(output)\n  })\n  \n  o"
	.ascii	"bserveEvent(input$showAll,{\n    if(error() != '' || is.null"
	.ascii	"(resTask()))\n      return(NULL)\n    \n    data <- resTask("
	.ascii	")$result\n    melted <- melt(data,id.vars='Time')\n    colna"
	.ascii	"mes(melted)[2:3] <- c('Species', 'Number')\n    colnames <- "
	.ascii	"unique(melted$Species)\n    if (input$showAll %% 2 == 0){\n "
	.ascii	"     updateCheckboxGroupInput(session=session,'columns', cho"
	.ascii	"ices= colnames, selected= colnames,inline = T)\n    }\n    e"
	.ascii	"lse {\n      updateCheckboxGroupInput(session=session,'colum"
	.ascii	"ns', choices= colnames, selected= NULL,inline = T)\n    }\n "
	.ascii	" })\n\n#### To generate options interface for tasks ####\n  "
	.ascii	"output$choose_options <- renderUI({\n    # If missing input,"
	.ascii	" return to avoid error later in function\n    if(length(get_"
	.ascii	"selected(input$taskSelection))==0)\n      return(NULL)\n    "
	.ascii	"else{\n      textOutput('selection')\n    }\n    output = ta"
	.ascii	"gList()\n    selectedTask <- selection()\n    if (selectedTa"
	.ascii	"sk %in% c('Reactions','Species','Compartments', 'Global Quan"
	.ascii	"tities','Events','Parameters','Stoichiometry')){\n      outp"
	.ascii	"ut[[1]] = ''\n    }\n    else if (selectedTask %in% c('Stead"
	.ascii	"y State','Linear Noise Approximation')){\n      if (selected"
	.ascii	"Task == 'Steady State'){\n        if (!is.null(inputFile$mod"
	.ascii	"elData)) settingTask = CoRC::getSS(model=inputFile$modelData"
	.ascii	")\n        output[[1]] = splitLayout(checkboxInput('calculat"
	.ascii	"eJacobian','calculate Jacobian', value= ifelse(is.null(input"
	.ascii	"File$modelData), T, settingTask$calculate_jacobian)),checkbo"
	.ascii	"xInput("
	.ascii	"'performStabilityAnalysis','perform Stability Analysis', val"
	.ascii	"ue= ifelse(is.null(inputFile$modelData), T, settingTask$perf"
	.ascii	"orm_stability_analysis)))\n      }\n      else {\n        if"
	.ascii	" (!is.null(inputFile$modelData))settingTask = CoRC::getLNA(m"
	.ascii	"odel=inputFile$modelData)\n        output[[1]] = checkboxInp"
	.ascii	"ut('lnaSelection','perform Steady State Analysis',value = if"
	.ascii	"else(is.null(inputFile$modelData), T, settingTask$perform_st"
	.ascii	"eady_state_analysis))\n      }\n      output[[2]] = splitLay"
	.ascii	"out(numericInput('resolution', 'Resolution:', ifelse(is.null"
	.ascii	"(inputFile$modelData), 1e-9, settingTask$method$resolution),"
	.ascii	" min = 1e-9, max = 1),numericInput('derivationFac', 'Derivat"
	.ascii	"ion Factor:', ifelse(is.null(inputFile$modelData), 1e-3, set"
	.ascii	"tingTask$method$derivation_factor), min = 1e-3, max = 1))\n "
	.ascii	"     output[[3]] = splitLayout(checkboxInput('useNewton','Us"
	.ascii	"e Newton', value= ifelse(is.null(inputFile$modelData), T, se"
	.ascii	"ttingTask$method$use_newton)),checkboxInput('useIntegration'"
	.ascii	",'Use Integration', value= ifelse(is.null(inputFile$modelDat"
	.ascii	"a), T, settingTask$method$use_integration)),checkboxInput('u"
	.ascii	"seBackIntegration','Use Back Integration', value= ifelse(is."
	.ascii	"null(inputFile$modelData), F, settingTask$method$use_back_in"
	.ascii	"tegration)))\n      output[[4]] = actionButton('runTask', 'R"
	.ascii	"un Task',icon=icon('angle-double-right'))\n      output[[5]]"
	.ascii	" = downloadButton('downloadData', 'Download Results')\n    }"
	.ascii	"\n    else if (selectedTask == 'Time Course'){\n      output"
	.ascii	"[[1]] = splitLayout(numericInput('obsTime', 'Duration [s]:',"
	.ascii	" ifelse(is.null(inputFile$modelData), 10, inputFile$settings"
	.ascii	"TC$duration), min = 1, max = 1000),numericInput('obsInterval"
	.ascii	"Size', 'Interval Size [s]:', ifelse(is.null(inputFile$modelD"
	.ascii	"ata), 1, inputFile$settingsTC$dt), min = 0.0001, max = 100))"
	.ascii	"\n      output[[2]] = checkboxInput('startSteady','start in "
	.ascii	"Steady State', value= ifelse(is.null(inputFile$modelData), F"
	.ascii	", inputFile$settingsTC$start_in_steady_state))\n      output"
	.ascii	"[[3]] = selectInput('timeCourseSelection', 'Select a Method:"
	.ascii	"', choices = c('Deterministic (LSO"
	.ascii	"DA)'='deterministic'\n                                      "
	.ascii	"                                                 ,'Stochasti"
	.ascii	"c (Gibson + Bruck) '='stochastic'\n                         "
	.ascii	"                                                            "
	.ascii	"  ,'Stochastic (Direct method)'='directMethod'\n            "
	.ascii	"                                                            "
	.ascii	"               ,'Stochastic (Tau leap)'='tauLeap'\n         "
	.ascii	"                                                            "
	.ascii	"                  ,'Stochastic (Adaptive SSA)'='adaptiveSA'\n"
	.ascii	"                                                            "
	.ascii	"                           ,'Hybrid (Runge-Kutta)'='hybrid'\n"
	.ascii	"                                                            "
	.ascii	"                           ,'Hybrid (LSODA)'='hybridLSODA'\n"
	.ascii	"                                                            "
	.ascii	"                           #,'Hybrid (RK45)'='hybridODE45'\n"
	.ascii	"                                                            "
	.ascii	"                           ,'SDE solver (RI5)'='stochasticRu"
	.ascii	"nkeKuttaRI5')\n                                ,selected = i"
	.ascii	"felse(is.null(inputFile$modelData), 'deterministic', inputFi"
	.ascii	"le$settingsTC$method$method))\n      output[[4]] = actionBut"
	.ascii	"ton('runTask', 'Run Task',icon=icon('angle-double-right'))\n"
	.ascii	"      output[[5]] = downloadButton('downloadData', 'Download"
	.ascii	" Results')\n    }\n    else if (selectedTask == 'Metabolic C"
	.ascii	"ontrol Analysis'){\n      if (!is.null(inputFile$modelData))"
	.ascii	" settingTask = CoRC::getMCA(model=inputFile$modelData)\n    "
	.ascii	"  output[[1]] = checkboxInput('mcaSelection','perform Steady"
	.ascii	" State Analysis',value = T)\n      output[[2]] = numericInpu"
	.ascii	"t('modulationFactor', 'Modulation Factor:', ifelse(is.null(i"
	.ascii	"nputFile$modelData), 1e-9, settingTask$method$modulation_fac"
	.ascii	"tor), min = 1e-9, max = 1)\n      output[[3]] = splitLayout("
	.ascii	"checkboxInput('useReder','Use Reder', value= ifelse(is.null("
	.ascii	"inputFile$modelData), T, settingTask$method$use_reder)),chec"
	.ascii	"kboxInput('useSmallbone','Use Smallbone', value= ifelse(is.n"
	.ascii	"ull(inputFile$modelData), T, settin"
	.ascii	"gTask$method$use_smallbone)))\n      output[[4]] = actionBut"
	.ascii	"ton('runTask', 'Run Task',icon=icon('angle-double-right'))\n"
	.ascii	"      output[[5]] = downloadButton('downloadData', 'Download"
	.ascii	" Results')\n    }\n    else if (selectedTask == 'Optimizatio"
	.ascii	"n'){\n      output[[1]] = tabsetPanel(id = 'PE',tabPanel('Pa"
	.ascii	"rameters', DT::dataTableOutput('tableParameterList')),tabPan"
	.ascii	"el('Constraints', DT::dataTableOutput('tableConstraintList')"
	.ascii	") )\n      output[[2]] = htmlOutput('selectedMethod')\n     "
	.ascii	" output[[3]] = actionButton('runTask', 'Run Task',icon=icon("
	.ascii	"'angle-double-right'))\n      output[[4]] = downloadButton('"
	.ascii	"downloadData', 'Download Results')\n    }\n    else if (sele"
	.ascii	"ctedTask == 'Parameter Estimation'){\n      output[[1]] = ta"
	.ascii	"bsetPanel(id = 'PE',tabPanel('Parameters', DT::dataTableOutp"
	.ascii	"ut('tableParameterList')),tabPanel('Constraints', DT::dataTa"
	.ascii	"bleOutput('tableConstraintList')) )\n      output[[2]] = htm"
	.ascii	"lOutput('selectedMethod')\n      output[[3]] = actionButton("
	.ascii	"'runTask', 'Run Task',icon=icon('angle-double-right'))\n    "
	.ascii	"  output[[4]] = downloadButton('downloadData', 'Download Res"
	.ascii	"ults')\n    }\n    return(output)\n  })\n  \n  ### Tree stru"
	.ascii	"cture for task selection\n  output$taskSelection <- renderTr"
	.ascii	"ee({ \n    structTree =list('Model'= structure(list('Compart"
	.ascii	"ments'= structure('1',sticon=''),'Species'= structure('2',st"
	.ascii	"icon=''),'Reactions'= structure('3',sticon=''),'Global Quant"
	.ascii	"ities'= structure('4',sticon=''),'Events'= structure('5',sti"
	.ascii	"con=''),'Parameters'= structure('6',sticon=''),'Stoichiometr"
	.ascii	"y'= structure('7',sticon='')),sticon='')\n                  "
	.ascii	"   ,'Tasks'= structure(list('Steady State'= structure('1',st"
	.ascii	"icon=''),'Time Course'= structure('2',sticon=''),'Metabolic "
	.ascii	"Control Analysis'= structure('3',sticon=''),'Optimizati"
	.string	"on'= structure('4',sticon=''),'Parameter Estimation'= structure('5',sticon=''),'Linear Noise Approximation'= structure('6',sticon='')), sticon=''))\n    attr(structTree[[1]],'stopened')=TRUE \n    attr(structTree[[2]],'stopened')=TRUE \n    structTree\n  })\n}\n"
	.section	.data.rel.local,"aw"
	.align 8
	.type	shinyServerString, @object
	.size	shinyServerString, 8
shinyServerString:
	.quad	.LC0
	.ident	"GCC: (Ubuntu 10.5.0-1ubuntu1~20.04) 10.5.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	 1f - 0f
	.long	 4f - 1f
	.long	 5
0:
	.string	 "GNU"
1:
	.align 8
	.long	 0xc0000002
	.long	 3f - 2f
2:
	.long	 0x3
3:
	.align 8
4:

	.arch armv5t
	.eabi_attribute 20, 1
	.eabi_attribute 21, 1
	.eabi_attribute 23, 3
	.eabi_attribute 24, 1
	.eabi_attribute 25, 1
	.eabi_attribute 26, 2
	.eabi_attribute 30, 6
	.eabi_attribute 34, 0
	.eabi_attribute 18, 4
	.file	"62638085.c"
	.text
	.section	.rodata
	.align	2
.LC0:
	.ascii	"## server file\012server <- function(input, output,"
	.ascii	" session) {\012  ## limit for the input file size\012"
	.ascii	"  options(shiny.maxRequestSize=30*1024^2) \012  ## "
	.ascii	"to store the current selection\012  selection <- re"
	.ascii	"nderText({\012    return(unlist(get_selected(input$"
	.ascii	"taskSelection)))\012  })\012  \012  ## to store the"
	.ascii	" error encountered\012  error <- renderText({\012  "
	.ascii	"  if (is.null(inputFile$dataPaths))\012      error "
	.ascii	"<- c('No model file loaded !!')\012    else if (is."
	.ascii	"null(inputFile$modelData))\012      error <- c('Ple"
	.ascii	"ase load a valid model file!!')\012    else if (exi"
	.ascii	"sts('message', where=resTask()))\012      error <- "
	.ascii	"c(resTask()$message)\012    else\012      error <- "
	.ascii	"''\012    \012    return(error)\012  })\012  \012  "
	.ascii	"## to display the error \012  output$errorOut <- re"
	.ascii	"nderText({\012    textOutput('error')\012    return"
	.ascii	"(error())\012  })\012  \012  ## To store the inform"
	.ascii	"ation of input model\012  inputFile <- reactiveValu"
	.ascii	"es()\012  observe({\012    \012    inputFile$fileNa"
	.ascii	"mes <- dir('copasi')\012    inputFile$dataPaths <- "
	.ascii	"paste0('copasi/',inputFile$fileNames)\012    \012  "
	.ascii	"  inputFile$dirName <- dirname(inputFile$dataPaths)"
	.ascii	"\012    inputFile$modelData <- NULL\012    inputFil"
	.ascii	"e$rootnode <- NULL\012    inputFile$modelLoaded <- "
	.ascii	"FALSE\012    for (i in 1:length(inputFile$fileNames"
	.ascii	")){\012      inputFileName <- inputFile$fileNames[i"
	.ascii	"]\012      if (grepl('\\\\.cps$',inputFileName)){\012"
	.ascii	"        inputFile$modelData <- CoRC::loadModel(inpu"
	.ascii	"tFile$dataPaths[i])\012        inputFile$modelName "
	.ascii	"<- inputFileName\012        inputFile$rootnode <- x"
	.ascii	"mlTreeParse(inputFile$dataPaths[i])\012        inpu"
	.ascii	"tFile$modelAttrs <- xmlAttrs(inputFile$rootnode$doc"
	.ascii	"$children$COPASI[names(inputFile$rootnode$doc$child"
	.ascii	"ren$COPASI)=='Model']$Model)\012        inputFile$m"
	.ascii	"odelLoaded <- TRUE\012      }\012    }\012    \012 "
	.ascii	"   if (is.null(inputFile$modelData)){\012      retu"
	.ascii	"rn(error())\012    }\012\012    inputFile$compartme"
	.ascii	"nts <- CoRC::getCompartments(model=inputFile$modelD"
	.ascii	"ata)\012    inputFile$species <- CoRC::getSpecies(m"
	.ascii	"odel=inputFile$modelData)\012    inputFile$reaction"
	.ascii	"s <- CoRC::getReactions(model=inputFile$modelData)\012"
	.ascii	"    inputFile$globalQuantities <- CoRC::getGlobalQu"
	.ascii	"antities(model=inputFile$mo"
	.ascii	"delData)\012    inputFile$events <- CoRC::getEvents"
	.ascii	"(model=inputFile$modelData)\012    inputFile$parame"
	.ascii	"ters <- CoRC::getParameters(model=inputFile$modelDa"
	.ascii	"ta)\012    inputFile$stoichiometry <- CoRC::getStoi"
	.ascii	"chiometryMatrix(model=inputFile$modelData)\012    i"
	.ascii	"nputFile$linkMatrix <- CoRC::getLinkMatrix(model=in"
	.ascii	"putFile$modelData)\012    inputFile$settingsTC <- C"
	.ascii	"oRC::getTC(model=inputFile$modelData)\012    inputF"
	.ascii	"ile$settingsOpt <- CoRC::getOpt(model=inputFile$mod"
	.ascii	"elData)\012    inputFile$settingsPE <- CoRC::getPE("
	.ascii	"model=inputFile$modelData)\012    inputFile$taskLis"
	.ascii	"t <- c('Compartments', 'Species', 'Reactions'\012  "
	.ascii	"                          ,'Global Quantities', 'Ev"
	.ascii	"ents', 'Parameters'\012                            "
	.ascii	",'Stoichiometry','Steady State','Time Course'\012  "
	.ascii	"                          ,'Metabolic Control Analy"
	.ascii	"sis','Optimization'\012                            "
	.ascii	",'Parameter Estimation', 'Linear Noise Approximatio"
	.ascii	"n')\012  })\012  \012  \012  ## Theme functions for"
	.ascii	" the plots\012  theme_pm <- function () {\012    th"
	.ascii	"eme_bw(base_size=12) + #base_family='Arial Black'\012"
	.ascii	"      theme(panel.grid=element_line(linetype='dashe"
	.ascii	"d', color='light grey', size=0.2),axis.ticks.length"
	.ascii	"=unit(-0.15, 'cm'),axis.text.x = element_text(margi"
	.ascii	"n=unit(c(0.25,0.25,0.25,0.25),'cm')),axis.text.y = "
	.ascii	"element_text(margin=unit(c(0.25,0.25,0.25,0.25),'cm"
	.ascii	"')))\012  }\012  \012  output$modelInfo <- renderTe"
	.ascii	"xt({\012    if (is.null(inputFile$modelData))\012  "
	.ascii	"    return()\012    selectedTask = selection()\012 "
	.ascii	"   strOut= paste('<h1>','Model Name:', inputFile$mo"
	.ascii	"delAttrs[[2]],'</h1>')\012    if (selectedTask %in%"
	.ascii	" inputFile$taskList ){\012      if (selectedTask =="
	.ascii	" 'Parameter Estimation' ){\012        expfileName= "
	.ascii	"''\012        valfileName= ''\012        if (xmlSiz"
	.ascii	"e(inputFile$rootnode$doc$children$COPASI[names(inpu"
	.ascii	"tFile$rootnode$doc$children$COPASI)=='ListOfTasks']"
	.ascii	"$ListOfTasks[[6]][[2]][[9]]) >= 1){\012          xm"
	.ascii	"lList= xmlChildren(inputFile$rootnode$doc$children$"
	.ascii	"COPASI[names(inputFile$rootnode$doc$children$COPASI"
	.ascii	")=='ListOfTasks']$ListOfTasks[[6]][[2]][[9]][[1]])\012"
	.ascii	"          for (i in 1:xmlSize(xmlList)){\012       "
	.ascii	"     p"
	.ascii	"aramValue= xmlToList(xmlList[[i]])\012            i"
	.ascii	"f (paramValue[[1]] == 'File Name'){\012            "
	.ascii	"  expfileName= paramValue[[3]]\012              bre"
	.ascii	"ak\012            }\012          }\012          if "
	.ascii	"(expfileName %in% inputFile$fileNames){\012        "
	.ascii	"    #file.copy(inputFile$dataPaths[inputFile$fileNa"
	.ascii	"mes == expfileName], paste0(inputFile$dirName,'/',e"
	.ascii	"xpfileName), overwrite = TRUE, recursive = FALSE,co"
	.ascii	"py.mode = TRUE, copy.date = FALSE)\012          }\012"
	.ascii	"          else\012            expfileName= paste(' "
	.ascii	"<font color=','red','>  Please load a valid data fi"
	.ascii	"le along with the model. File name: <b>', expfileNa"
	.ascii	"me ,'</b> </font> ')\012        }\012          \012"
	.ascii	"        if (xmlSize(inputFile$rootnode$doc$children"
	.ascii	"$COPASI[names(inputFile$rootnode$doc$children$COPAS"
	.ascii	"I)=='ListOfTasks']$ListOfTasks[[6]][[2]][[10]]) > 2"
	.ascii	"){\012          xmlList= xmlChildren(inputFile$root"
	.ascii	"node$doc$children$COPASI[names(inputFile$rootnode$d"
	.ascii	"oc$children$COPASI)=='ListOfTasks']$ListOfTasks[[6]"
	.ascii	"][[2]][[10]][[1]])\012          for (i in 1:xmlSize"
	.ascii	"(xmlList)){\012            paramValue= xmlToList(xm"
	.ascii	"lList[[i]])\012            if (paramValue[[1]] == '"
	.ascii	"File Name'){\012              valfileName= paramVal"
	.ascii	"ue[[3]]\012              break\012            }\012"
	.ascii	"          }\012          if (valfileName %in% input"
	.ascii	"File$fileNames){\012            #file.copy(inputFil"
	.ascii	"e$dataPaths[inputFile$fileNames == valfileName], pa"
	.ascii	"ste0(inputFile$dirName,'/',valfileName), overwrite "
	.ascii	"= TRUE, recursive = FALSE,copy.mode = TRUE, copy.da"
	.ascii	"te = FALSE)\012          }\012          else\012   "
	.ascii	"         valfileName= paste(' <font color=','red','"
	.ascii	">  Please load a valid data file along with the mod"
	.ascii	"el. File name: <b>', valfileName ,'</b> </font> ')\012"
	.ascii	"        }\012        strOut= paste(strOut, '<h2>',s"
	.ascii	"electedTask,'</h2>')\012        strOut= paste(strOu"
	.ascii	"t, '<pre><b> Experimental Data: </b>',expfileName,'"
	.ascii	"<br> <br>')\012        strOut= paste(strOut, '<b>Va"
	.ascii	"lidation Data: </b>',valfileName,'<br>')\012       "
	.ascii	" strOut= paste(strOut, '<pre><b> Randomize Start Va"
	.ascii	"lues: </b>',inputFile$settingsPE$randomize_start_va"
	.ascii	"lues)\012        strOut= paste(strOut, '<b>  Calcul"
	.ascii	"ate Statistics: </b>',inputFile$settingsPE$calculat"
	.ascii	"e_statistics, '</pre></pre>')\012      }\012      e"
	.ascii	"lse if (selectedTask == 'Optimization' ){\012      "
	.ascii	"  strOut= paste(strOut, '<h2>',selectedTask,'</h2>'"
	.ascii	")\012        strOut= paste(strOut, '<pre><b> Expres"
	.ascii	"sion: </b>',inputFile$settingsOpt$expression)\012  "
	.ascii	"      strOut= paste(strOut, '<pre><b> Maxmize: </b>"
	.ascii	"',inputFile$settingsOpt$maximize, '</pre>')\012    "
	.ascii	"    strOut= paste(strOut, '<b>Subtask: </b>',inputF"
	.ascii	"ile$settingsOpt$subtask)\012        strOut= paste(s"
	.ascii	"trOut, '<pre><b> Randomize Start Values: </b>',inpu"
	.ascii	"tFile$settingsOpt$randomize_start_values)\012      "
	.ascii	"  strOut= paste(strOut, '<b>  Calculate Statistics:"
	.ascii	" </b>',inputFile$settingsOpt$calculate_statistics, "
	.ascii	"'</pre></pre>')\012      }\012      else\012       "
	.ascii	" strOut= paste(strOut, '<h2>',selectedTask,'</h2>')"
	.ascii	"\012    }\012    else if (selectedTask == 'Model' |"
	.ascii	"| inputFile$modelLoaded == T){\012      strOut= pas"
	.ascii	"te('<pre><b> Model: </b>',inputFile$modelAttrs[[2]]"
	.ascii	",'<br>')\012      strOut= paste(strOut,'<pre><table"
	.ascii	"><tr><th>Time Unit:</th><td>',inputFile$modelAttrs["
	.ascii	"[4]]\012                    ,'</td><th>Volume Unit:"
	.ascii	"</th><td>',inputFile$modelAttrs[[5]],'</td></tr>')\012"
	.ascii	"      strOut= paste(strOut,'<tr><th>Quantity Unit:<"
	.ascii	"/th><td>',inputFile$modelAttrs[[8]]\012            "
	.ascii	"        ,'</td><th>Area Unit:</th><td>',inputFile$m"
	.ascii	"odelAttrs[[6]],'</td></tr>')\012      strOut= paste"
	.ascii	"(strOut,'<tr><th>Avogadro Constant:</th><td>',input"
	.ascii	"File$modelAttrs[[10]]\012                    ,'</td"
	.ascii	"><th>Length Unit:</th><td>',inputFile$modelAttrs[[7"
	.ascii	"]],'</td></tr></table></pre></pre>')\012      }\012"
	.ascii	"    return(strOut)\012  })\012  \012  output$select"
	.ascii	"edMethod<- renderText({\012    if (is.null(inputFil"
	.ascii	"e$rootnode))\012      return()\012    \012    selec"
	.ascii	"tedTask = selection()\012    if (selectedTask == 'P"
	.ascii	"arameter Estimation' ){\012      methodSetting= inp"
	.ascii	"utFile$settingsPE$method\012    }\012    else if(se"
	.ascii	"lectedTask == 'Optimization' ){\012      methodSett"
	.ascii	"ing= inputFile$settingsOpt$method\012    }\012    e"
	.ascii	"lse{\012      return()\012    }\012  \012    strOut"
	.ascii	"= ''\012    namesMethod= paste0(toupper(substring(n"
	.ascii	"ames(methodSetting),1,1)),sub"
	.ascii	"string(names(methodSetting),2))\012    strOut= past"
	.ascii	"e('<pre><b>',namesMethod[[1]],'</b>:',methodSetting"
	.ascii	"[[1]],'<br><pre>')\012    for (i in 2:length(namesM"
	.ascii	"ethod)){\012      strOut= paste(strOut, '<b>',names"
	.ascii	"Method[[i]],'</b>:&nbsp ', methodSetting[[i]], '<br"
	.ascii	">')\012    }\012    return(paste(strOut,'</pre></pr"
	.ascii	"e>'))\012  })\012    \012  paramList <- function ()"
	.ascii	" {\012    if (is.null(inputFile$rootnode))\012     "
	.ascii	" return()\012    \012    selectedTask = selection()"
	.ascii	"\012    if (selectedTask == 'Parameter Estimation' "
	.ascii	"){\012      xmlList= inputFile$rootnode$doc$childre"
	.ascii	"n$COPASI[names(inputFile$rootnode$doc$children$COPA"
	.ascii	"SI)=='ListOfTasks']$ListOfTasks[[6]][[2]][[4]]\012 "
	.ascii	"   }\012    else if(selectedTask == 'Optimization' "
	.ascii	"){\012      xmlList= inputFile$rootnode$doc$childre"
	.ascii	"n$COPASI[names(inputFile$rootnode$doc$children$COPA"
	.ascii	"SI)=='ListOfTasks']$ListOfTasks[[5]][[2]][[6]]\012 "
	.ascii	"   }\012    else{\012      return()\012    }\012   "
	.ascii	" \012    numParameters= xmlSize(xmlChildren(xmlList"
	.ascii	"))\012    if (numParameters < 1)\012      return()\012"
	.ascii	"    resTable <- setNames(data.frame(matrix(ncol = 4"
	.ascii	", nrow = numParameters)), c('LowerBound', 'Paramete"
	.ascii	"r', 'UpperBound','StartValue'))\012    for (i in 1:"
	.ascii	"numParameters){\012      xmlListIN <- xmlChildren(x"
	.ascii	"mlList[[i]])\012      for (j in 1:xmlSize(xmlListIN"
	.ascii	")){\012        checkParam = names(xmlListIN) == 'Pa"
	.ascii	"rameter'\012        if (checkParam[j]){\012        "
	.ascii	"  paramValue= xmlToList(xmlListIN[[j]])\012        "
	.ascii	"  if (paramValue[[1]] == 'LowerBound'){\012        "
	.ascii	"    resTable$LowerBound[i] = paramValue[[3]]\012   "
	.ascii	"       }\012          else if (paramValue[[1]]== 'O"
	.ascii	"bjectCN'){\012            resTable$Parameter[i] = g"
	.ascii	"sub(',Reference=','.',gsub('.*Vector=','',paramValu"
	.ascii	"e[[3]]))\012          }\012          else if (param"
	.ascii	"Value[[1]]== 'UpperBound'){\012            resTable"
	.ascii	"$UpperBound[i] = paramValue[[3]]\012          }\012"
	.ascii	"          else if (paramValue[[1]]== 'StartValue'){"
	.ascii	"\012            resTable$StartValue[i] = paramValue"
	.ascii	"[[3]]\012          }}}}\012    return(resTable)\012"
	.ascii	"  }\012  \012  constrList <- function () {\012    i"
	.ascii	"f (is.null(inputFile$rootnode))\012      return()\012"
	.ascii	"    \012    selectedTask = selection()\012    if (s"
	.ascii	"electedTask "
	.ascii	"== 'Parameter Estimation' ){\012      xmlList= inpu"
	.ascii	"tFile$rootnode$doc$children$COPASI[names(inputFile$"
	.ascii	"rootnode$doc$children$COPASI)=='ListOfTasks']$ListO"
	.ascii	"fTasks[[6]][[2]][[5]]\012    }\012    else if(selec"
	.ascii	"tedTask == 'Optimization' ){\012      xmlList= inpu"
	.ascii	"tFile$rootnode$doc$children$COPASI[names(inputFile$"
	.ascii	"rootnode$doc$children$COPASI)=='ListOfTasks']$ListO"
	.ascii	"fTasks[[5]][[2]][[7]]\012    }\012    else{\012    "
	.ascii	"  return()\012    }\012\012    numParameters= xmlSi"
	.ascii	"ze(xmlChildren(xmlList))\012    if (numParameters <"
	.ascii	" 1)\012      return()\012    resTable <- setNames(d"
	.ascii	"ata.frame(matrix(ncol = 3, nrow = numParameters)), "
	.ascii	"c('LowerBound', 'Parameter', 'UpperBound'))\012    "
	.ascii	"\012    for (i in 1:numParameters){\012      xmlLis"
	.ascii	"tIN <- xmlChildren(xmlList[[i]])\012      for (j in"
	.ascii	" 1:xmlSize(xmlListIN)){\012        checkParam = nam"
	.ascii	"es(xmlListIN) == 'Parameter'\012        if (checkPa"
	.ascii	"ram[j]){\012          paramValue= xmlToList(xmlList"
	.ascii	"IN[[j]])\012          if (paramValue[[1]] == 'Lower"
	.ascii	"Bound'){\012            resTable$LowerBound[i] = pa"
	.ascii	"ramValue[[3]]\012          }\012          else if ("
	.ascii	"paramValue[[1]]== 'ObjectCN'){\012            resTa"
	.ascii	"ble$Parameter[i] = gsub(',Reference=','.',gsub('.*V"
	.ascii	"ector=','',paramValue[[3]]))\012          }\012    "
	.ascii	"      else if (paramValue[[1]]== 'UpperBound'){\012"
	.ascii	"            resTable$UpperBound[i] = paramValue[[3]"
	.ascii	"]\012            }}}}\012    return(resTable)\012  "
	.ascii	"}\012  \012\012#### To execute different tasks ####"
	.ascii	"\012  resTask <- eventReactive(input$runTask, {\012"
	.ascii	"    modelData <- inputFile$modelData\012    selecte"
	.ascii	"dTask <- selection()\012    \012    progress <- shi"
	.ascii	"ny::Progress$new() # Create a Progress object\012  "
	.ascii	"  on.exit(progress$close()) # To make sure it close"
	.ascii	"s when we exit this reactive, even if there's an er"
	.ascii	"ror\012    progress$set(message = paste('Running ',"
	.ascii	" selectedTask), value = 0)\012\012    if (selectedT"
	.ascii	"ask %in% c('Steady State','Linear Noise Approximati"
	.ascii	"on')){\012      if (selectedTask == 'Steady State')"
	.ascii	" settingTask = CoRC::getSS(model=modelData)\012    "
	.ascii	"  else settingTask = CoRC::getLNA(model=modelData)\012"
	.ascii	"      settingTask$method$resolution = input$resolut"
	.ascii	"ion\012      settingTask$method$derivation_fact"
	.ascii	"or = input$derivationFac\012      settingTask$metho"
	.ascii	"d$use_newton = input$useNewton\012      settingTask"
	.ascii	"$method$use_integration = input$useIntegration\012 "
	.ascii	"     settingTask$method$use_back_integration = inpu"
	.ascii	"t$useBackIntegration\012      if (selectedTask == '"
	.ascii	"Steady State') resTask <- tryCatch(CoRC::runSS(calc"
	.ascii	"ulate_jacobian = input$calculateJacobian,perform_st"
	.ascii	"ability_analysis =input$performStabilityAnalysis,me"
	.ascii	"thod=settingTask$method,model=modelData), warning ="
	.ascii	" function(warning_condition){return(warning_conditi"
	.ascii	"on) }, error = function(error_condition){return(err"
	.ascii	"or_condition) })\012      if (selectedTask == 'Line"
	.ascii	"ar Noise Approximation') resTask <- tryCatch(CoRC::"
	.ascii	"runLNA(perform_steady_state_analysis = input$lnaSel"
	.ascii	"ection,method=settingTask$method,model=modelData), "
	.ascii	"warning = function(warning_condition){return(warnin"
	.ascii	"g_condition) }, error = function(error_condition){r"
	.ascii	"eturn(error_condition) })\012    }\012    else if ("
	.ascii	"selectedTask == 'Time Course'){\012      resTask <-"
	.ascii	" tryCatch(CoRC::runTC(duration=input$obsTime,dt=inp"
	.ascii	"ut$obsIntervalSize,start_in_steady_state=input$star"
	.ascii	"tSteady,method=input$timeCourseSelection,model=mode"
	.ascii	"lData,save_result_in_memory = T), warning = functio"
	.ascii	"n(warning_condition){return(warning_condition) }, e"
	.ascii	"rror = function(error_condition){return(error_condi"
	.ascii	"tion) })\012    }\012    else if(selectedTask == 'M"
	.ascii	"etabolic Control Analysis'){\012      settingTask ="
	.ascii	" CoRC::getMCA(model=modelData)\012      settingTask"
	.ascii	"$method$modulation_factor = input$modulationFactor\012"
	.ascii	"      settingTask$method$use_reder = input$useReder"
	.ascii	"\012      settingTask$method$use_smallbone = input$"
	.ascii	"useSmallbone\012      resTask <- tryCatch(CoRC::run"
	.ascii	"MCA(perform_steady_state_analysis = input$mcaSelect"
	.ascii	"ion, method= settingTask$method, model=modelData), "
	.ascii	"warning = function(warning_condition){return(warnin"
	.ascii	"g_condition) }, error = function(error_condition){r"
	.ascii	"eturn(error_condition) })\012    }\012    else if ("
	.ascii	"selectedTask == 'Optimization'){\012      resTask <"
	.ascii	"- tryCatch(CoRC::runOptimization(model=modelData), "
	.ascii	"warning = function(warning_condition){return(warnin"
	.ascii	"g_condition"
	.ascii	") }, error = function(error_condition){return(error"
	.ascii	"_condition) })\012    }\012    else if (selectedTas"
	.ascii	"k == 'Parameter Estimation'){\012      resTask <- t"
	.ascii	"ryCatch(CoRC::runParameterEstimation(model=modelDat"
	.ascii	"a), warning = function(warning_condition){return(wa"
	.ascii	"rning_condition) }, error = function(error_conditio"
	.ascii	"n){return(error_condition) })\012    }\012    else\012"
	.ascii	"      resTask <- 'No Task found'\012\012    return("
	.ascii	"resTask)\012  })\012  \012#### To download tables f"
	.ascii	"or different tasks ####  \012  ## For data download"
	.ascii	"\012  output$downloadData<-downloadHandler(\012    "
	.ascii	"filename = function() { \012      if (is.null(input"
	.ascii	"File$dataPaths))\012        return(NULL)\012      p"
	.ascii	"aste(sub('\\\\..*$', '',inputFile$modelName) , '.cs"
	.ascii	"v', sep='')\012      },\012    content = function(f"
	.ascii	"ile) {\012      if (is.null(file) || error() != '' "
	.ascii	"|| is.null(resTask()))\012        return(NULL)\012 "
	.ascii	"     selectedTask <- selection()\012      if (selec"
	.ascii	"tedTask == 'Steady State'){\012        writeData <-"
	.ascii	" resTask()$species[,c('name','concentration','rate'"
	.ascii	",'transition_time')]\012      }\012      else if (s"
	.ascii	"electedTask == 'Time Course' && 'Time' %in% names(r"
	.ascii	"esTask()$result) && !is.null(input$columns)){\012  "
	.ascii	"      writeData <- resTask()$result[, c('Time',inpu"
	.ascii	"t$columns), drop = FALSE]\012      }\012      else "
	.ascii	"if(selectedTask == 'Metabolic Control Analysis'){\012"
	.ascii	"        writeData <- resTask()$elasticities_unscale"
	.ascii	"d\012      }\012      else  if(selectedTask == 'Opt"
	.ascii	"imization'){\012        writeData <- resTask()$para"
	.ascii	"meters\012      }\012      else if(selectedTask == "
	.ascii	"'Parameter Estimation'){\012        writeData <- re"
	.ascii	"sTask()$parameter\012      }\012      else if (sele"
	.ascii	"ctedTask == 'Linear Noise Approximation'){\012     "
	.ascii	"   writeData <- resTask()$covariance_matrix\012    "
	.ascii	"  }\012      else\012        writeData <- 'No Data "
	.ascii	"found'\012      \012      write.csv(writeData,file)"
	.ascii	"\012    }\012  )\012  \012  ## For model download\012"
	.ascii	"  output$downloadModel<-downloadHandler(\012    fil"
	.ascii	"ename = function() { \012      if (is.null(inputFil"
	.ascii	"e$dataPaths))\012        return(NULL)\012      past"
	.ascii	"e(sub('\\\\..*$', '',inputFile$modelName) , '.zip',"
	.ascii	" sep='')\012    },\012    content = function(file) "
	.ascii	"{\012      zipr(file,in"
	.ascii	"putFile$dataPaths)\012    },\012    contentType = '"
	.ascii	"application/zip'\012  )\012  \012#### To render out"
	.ascii	"put tables for different tasks ####\012  \012  ## O"
	.ascii	"utput task-specific results\012  output$tableResult"
	.ascii	"s1 <- DT::renderDataTable({\012    if (error() != '"
	.ascii	"' || is.null(resTask()))\012      return(NULL)\012 "
	.ascii	"   \012    selectedTask <- selection()\012    if (s"
	.ascii	"electedTask == 'Steady State'){\012      return(res"
	.ascii	"Task()$species[,c('name','concentration','rate','tr"
	.ascii	"ansition_time')])\012    }\012    else if (selected"
	.ascii	"Task == 'Time Course' && 'Time' %in% names(resTask("
	.ascii	")$result) && !is.null(input$columns)){\012      ret"
	.ascii	"urn(resTask()$result[, c('Time',input$columns), dro"
	.ascii	"p = FALSE])\012    }\012    else if(selectedTask =="
	.ascii	" 'Metabolic Control Analysis'){\012      return(res"
	.ascii	"Task()$elasticities_unscaled)\012    }\012    else "
	.ascii	"if(selectedTask %in% c('Optimization','Parameter Es"
	.ascii	"timation') && !is.null(resTask()$main)){\012      d"
	.ascii	"ata <- t(as.data.frame(resTask()$main))\012      co"
	.ascii	"lnames(data) <- c('Value')\012      return(data)\012"
	.ascii	"    }\012    else\012      return(NULL)\012    },op"
	.ascii	"tions = list(scrollX = TRUE, scrollY = '400px'))\012"
	.ascii	"  \012  \012  output$tableResults2 <- DT::renderDat"
	.ascii	"aTable({\012    if (error() != '' || is.null(resTas"
	.ascii	"k()))\012      return(NULL)\012    \012    selected"
	.ascii	"Task <- selection()\012    if (selectedTask == 'Ste"
	.ascii	"ady State'){\012      colNames <- colnames(resTask("
	.ascii	")$jacobian_complete)\012      data <- data.frame(re"
	.ascii	"sTask()$jacobian_complete)\012      data <- formatt"
	.ascii	"able(data, list(area(col = colnames(data)) ~ color_"
	.ascii	"tile('lightpink', 'lightgreen')))\012      colnames"
	.ascii	"(data) <- colNames\012      return(as.datatable(dat"
	.ascii	"a,options = list(scrollX = TRUE, scrollY = '400px')"
	.ascii	"))\012    }\012    else if(selectedTask == 'Metabol"
	.ascii	"ic Control Analysis'){\012      return(resTask()$el"
	.ascii	"asticities_unscaled)\012    }\012    else if(select"
	.ascii	"edTask == 'Optimization'){\012      return(resTask("
	.ascii	")$parameters)\012    }\012    else if(selectedTask "
	.ascii	"== 'Parameter Estimation'){\012      return(resTask"
	.ascii	"()$parameter)\012    }\012    else if(selectedTask "
	.ascii	"== 'Linear Noise Approximation'){\012\011   colName"
	.ascii	"s <- colnames(resTask()$covariance_matrix)\012     "
	.ascii	" data <- data.frame(resT"
	.ascii	"ask()$covariance_matrix)\012      data <- formattab"
	.ascii	"le(data, list(area(col = colnames(data)) ~ color_ti"
	.ascii	"le('lightpink', 'lightgreen')))\012      colnames(d"
	.ascii	"ata) <- colNames\012      return(as.datatable(data,"
	.ascii	"options = list(scrollX = TRUE, scrollY = '400px')))"
	.ascii	"\012    }\012    else\012      return(NULL)\012  })"
	.ascii	"\012  \012  output$tablePEexp <- DT::renderDataTabl"
	.ascii	"e({\012    if (error() != '' || is.null(resTask()))"
	.ascii	"\012      return(NULL)\012    return(resTask()$expe"
	.ascii	"riments)\012  },options = list(scrollX = TRUE, scro"
	.ascii	"llY = '400px'))\012  \012  \012  ## Display the sel"
	.ascii	"ected parameters and constraints \012  output$table"
	.ascii	"ParameterList <- DT::renderDataTable({\012    if(!i"
	.ascii	"s.null(paramList())) return(paramList())\012  },opt"
	.ascii	"ions = list(scrollX = TRUE, scrollY = '200px'))\012"
	.ascii	"  \012  output$tableConstraintList <- DT::renderDat"
	.ascii	"aTable({\012    if (!is.null(constrList())) return("
	.ascii	"constrList())\012  },options = list(scrollX = TRUE,"
	.ascii	" scrollY = '200px'))\012  \012  ## Display informat"
	.ascii	"ion of the loaded model\012  output$tableModel <- D"
	.ascii	"T::renderDataTable({\012    if (is.null(inputFile$m"
	.ascii	"odelData))\012      return()\012    selectedTask <-"
	.ascii	" selection()\012    tableModel <-  data.frame()\012"
	.ascii	"    if (selectedTask == 'Compartments'){\012      t"
	.ascii	"ableModel <- inputFile$compartments\012      if (!i"
	.ascii	"s.null(tableModel)){\012        tableModel <- table"
	.ascii	"Model[,c(-1)]    \012      }}\012    else if (selec"
	.ascii	"tedTask == 'Species'){\012      tableModel <- input"
	.ascii	"File$species\012      tableModel <- tableModel[,c(-"
	.ascii	"1,-7,-9,-11)]\012    }\012    else if (selectedTask"
	.ascii	" == 'Reactions'){\012      tableModel <- inputFile$"
	.ascii	"reactions\012      if (!is.null(tableModel)){\012  "
	.ascii	"      tableModel <- tableModel[,c('name','reaction'"
	.ascii	",'rate_law','flux')]\012        tableModel$rate_law"
	.ascii	" <- gsub('.*\\\\[|\\\\]', '', tableModel$rate_law) "
	.ascii	"       \012      }}\012    else if (selectedTask =="
	.ascii	" 'Global Quantities'){\012      tableModel <- input"
	.ascii	"File$globalQuantities\012      tableModel <- tableM"
	.ascii	"odel[,-1]\012    } \012    else if (selectedTask =="
	.ascii	" 'Events'){\012      tableModel <- data.frame(input"
	.ascii	"File$events)\012      if (!is.null(tableModel)){\012"
	.ascii	"        tableModel <- tableModel[,-1]\012        ta"
	.ascii	"bleModel$assignment_tar"
	.ascii	"get <- gsub('.*\\\\(|\\\\)', '', tableModel$assignm"
	.ascii	"ent_target)\012        tableModel$assignment_expres"
	.ascii	"sion <- gsub('.*\\\\(|\\\\)', '', tableModel$assign"
	.ascii	"ment_expression)\012      }} \012    else if (selec"
	.ascii	"tedTask == 'Parameters'){\012      tableModel <- in"
	.ascii	"putFile$parameters\012      if (!is.null(tableModel"
	.ascii	")){\012        tableModel <- tableModel[,-1]\012   "
	.ascii	"     tableModel$mapping <- gsub('.*\\\\[|\\\\]', ''"
	.ascii	", tableModel$mapping)  \012      }}\012    return(t"
	.ascii	"ableModel)\012  },options = list(scrollX = TRUE, sc"
	.ascii	"rollY = '400px'))\012  \012  output$tableLM <- DT::"
	.ascii	"renderDataTable({\012    if (is.null(inputFile$mode"
	.ascii	"lData))\012      return()\012    colNames <- colnam"
	.ascii	"es(inputFile$linkMatrix)\012    data <- data.frame("
	.ascii	"inputFile$linkMatrix)\012    data <- formattable(da"
	.ascii	"ta, list(area(col = colnames(data)) ~ color_tile('l"
	.ascii	"ightpink', 'lightgreen')))\012    colnames(data) <-"
	.ascii	" colNames\012    return(as.datatable(data,options ="
	.ascii	" list(scrollX = TRUE, scrollY = '400px')))\012  })\012"
	.ascii	"  output$tableStoich <- DT::renderDataTable({\012  "
	.ascii	"  if (is.null(inputFile$modelData))\012      return"
	.ascii	"()\012    colNames <- colnames(inputFile$stoichiome"
	.ascii	"try)\012    data <- data.frame(inputFile$stoichiome"
	.ascii	"try)\012    data <- formattable(data, list(area(col"
	.ascii	" = colnames(data)) ~ color_tile('lightpink', 'light"
	.ascii	"green')))\012    colnames(data) <- colNames\012    "
	.ascii	"return(as.datatable(data,options = list(scrollX = T"
	.ascii	"RUE, scrollY = '400px')))\012  })\012\012#### To re"
	.ascii	"nder UI and plots for different tasks ####\012  out"
	.ascii	"put$plotOverview <- renderPlot({\012    selectedTas"
	.ascii	"k <- selection()\012    if (selectedTask == 'Specie"
	.ascii	"s'){\012      tableSpecies <- inputFile$species\012"
	.ascii	"      if (!is.null(tableSpecies) && nrow(tableSpeci"
	.ascii	"es) !=0 ){\012        ylabel <- paste('Concentratio"
	.ascii	"n (',tableSpecies$unit[1], ')')\012        barplot("
	.ascii	"tableSpecies$initial_concentration, main='Species o"
	.ascii	"verview',  ylab=ylabel, names.arg=tableSpecies$name"
	.ascii	", cex.names=0.8,las=2)\012      }\012    }\012    e"
	.ascii	"lse if (selectedTask == 'Global Quantities'){\012  "
	.ascii	"    tableGlobalQuantities <- inputFile$globalQuanti"
	.ascii	"ties\012      if (!is.null(tableGlobalQuantities) &"
	.ascii	"& nrow(tableGlobalQuantities) !=0 ){\012        ba"
	.ascii	"rplot(tableGlobalQuantities$initial_value, main='Gl"
	.ascii	"obal Quantities overview', ylab= 'Initial value', n"
	.ascii	"ames.arg=tableGlobalQuantities$name, cex.names=0.8,"
	.ascii	"las=2)\012      }\012    }\012    else if (selected"
	.ascii	"Task == 'Parameters'){\012      tableParameters <- "
	.ascii	"inputFile$parameters\012      if (!is.null(tablePar"
	.ascii	"ameters) && nrow(tableParameters) !=0 && !all(is.na"
	.ascii	"(tableParameters$value))){\012        barplot(table"
	.ascii	"Parameters$value, main='Parameters overview', ylab="
	.ascii	"'Value', names.arg=tableParameters$name, cex.names="
	.ascii	"0.8,las=2)\012      }\012    }\012  })\012  \012  o"
	.ascii	"utput$plotTC <- renderPlot({\012    if (error() != "
	.ascii	"'' || is.null(resTask()) || is.null(input$columns))"
	.ascii	"\012      return(NULL)\012    \012    selectedTask "
	.ascii	"<- selection()\012    data <- resTask()$result\012 "
	.ascii	"   if (selectedTask == 'Time Course' && 'Time' %in%"
	.ascii	" names(data)){\012      data <- data[, c('Time',inp"
	.ascii	"ut$columns), drop = FALSE]\012      melted <- melt("
	.ascii	"data,id.vars='Time')\012      colnames(melted)[2:3]"
	.ascii	" <- c('Species', 'Number')\012      plot <- ggplot("
	.ascii	"melted, aes(x=Time, y=Number, group=Species, color="
	.ascii	" Species)) + geom_line(size = 1) + theme_classic(ba"
	.ascii	"se_size = 18) + ggtitle('Time-course of selected sp"
	.ascii	"ecies') + ylab('Concentration') + xlab('Time (s)') "
	.ascii	"+ theme_pm()\012      print(plot)\012    }\012    e"
	.ascii	"lse{\012      textOutput('error')\012    }\012  })\012"
	.ascii	"\012  ## To load the output UI showing table/Plot\012"
	.ascii	"  output$show_output<- renderUI({\012    selectedTa"
	.ascii	"sk <- selection()\012    if (is.null(inputFile$mode"
	.ascii	"lData))\012      return(NULL)\012    if (selectedTa"
	.ascii	"sk %in% c('Species','Global Quantities','Parameters"
	.ascii	"')){\012      tabsetPanel(id = 'mdl',tabPanel('Tabl"
	.ascii	"e',DT::dataTableOutput('tableModel')),tabPanel('Ove"
	.ascii	"rview', plotOutput('plotOverview')))\012    }\012  "
	.ascii	"  else if (selectedTask %in% c('Reactions','Compart"
	.ascii	"ments', 'Events')){\012        tabPanel('mdlTable',"
	.ascii	"DT::dataTableOutput('tableModel'))\012    }\012    "
	.ascii	"else if(selectedTask == 'Stoichiometry'){\012      "
	.ascii	"tabsetPanel(id = 'mdlTable',tabPanel('Stoichiometry"
	.ascii	" Matrix',DT::dataTableOutput('tableStoich')),tabPan"
	.ascii	"el('Link Matrix',DT::dataTableOutput('tableLM')))\012"
	.ascii	"    }\012    else if (selectedT"
	.ascii	"ask == 'Time Course'){\012      tabsetPanel(id = 'T"
	.ascii	"C',tabPanel('Time Course',DT::dataTableOutput('tabl"
	.ascii	"eResults1')),tabPanel('Plot', plotOutput('plotTC'))"
	.ascii	")\012    }\012    else if (selectedTask == 'Steady "
	.ascii	"State'){\012      tabsetPanel(id = 'SS',tabPanel('S"
	.ascii	"teady State', DT::dataTableOutput('tableResults1'))"
	.ascii	",tabPanel('Jacobian', DT::dataTableOutput('tableRes"
	.ascii	"ults2')))\012    }\012    else if(selectedTask == '"
	.ascii	"Metabolic Control Analysis'){\012      tabPanel('Ta"
	.ascii	"ble',DT::dataTableOutput('tableResults1'))\012    }"
	.ascii	"\012    else if(selectedTask == 'Optimization'){\012"
	.ascii	"      tabsetPanel(id = 'PE',tabPanel('Main',DT::dat"
	.ascii	"aTableOutput('tableResults1')),tabPanel('Optimized "
	.ascii	"Parameters',DT::dataTableOutput('tableResults2')))\012"
	.ascii	"    }\012    else if(selectedTask == 'Parameter Est"
	.ascii	"imation'){\012      tabsetPanel(id = 'PE',tabPanel("
	.ascii	"'Main',DT::dataTableOutput('tableResults1')),tabPan"
	.ascii	"el('Fitted Parameters',DT::dataTableOutput('tableRe"
	.ascii	"sults2')),tabPanel('Experiments', DT::dataTableOutp"
	.ascii	"ut('tablePEexp')))\012    }\012    else if(selected"
	.ascii	"Task == 'Linear Noise Approximation'){\012      tab"
	.ascii	"Panel('Table',DT::dataTableOutput('tableResults2'))"
	.ascii	"\012    }\012    else{\012    }\012  })\012  output"
	.ascii	"$SSmsg <- renderText({\012    selectedTask <- selec"
	.ascii	"tion()\012    resStr =ifelse(selectedTask == 'Stead"
	.ascii	"y State' && !is.null(resTask()$result),resTask()$re"
	.ascii	"sult,ifelse(!is.null(resTask()$result_ss),resTask()"
	.ascii	"$result_ss,return(NULL)))\012    if(resStr == 'foun"
	.ascii	"d') return('<pre> <b> Steady state found !!</b></pr"
	.ascii	"e>')\012    else if(resStr == 'foundEquilibrium') r"
	.ascii	"eturn('<pre> <b> Equilibrium steady state found!!</"
	.ascii	"b></pre>')\012    else return('<pre> <b> No steady "
	.ascii	"state found !!</b></pre>')\012  })\012  \012#### To"
	.ascii	" choose species for table and plot output ** ONLY F"
	.ascii	"OR TIME_COURSE ** ####\012  output$choose_columns <"
	.ascii	"- renderUI({\012    # If missing input, return to a"
	.ascii	"void error later in function\012    if(error() != '"
	.ascii	"' || is.null(resTask()))\012      return(NULL)\012 "
	.ascii	"   selectedTask <- selection()\012    output = tagL"
	.ascii	"ist()\012    if (selectedTask %in% c('Steady State'"
	.ascii	",'Linear Noise Approximation')){\012      output[[1"
	.ascii	"]] =  htmlOutput"
	.ascii	"('SSmsg')\012    }\012    else if (selectedTask == "
	.ascii	"'Time Course' && 'Time' %in% names(resTask()$result"
	.ascii	")){\012      data <- resTask()$result\012      # Ge"
	.ascii	"t the data set with the appropriate name\012      m"
	.ascii	"elted <- melt(data,id.vars='Time')\012      colname"
	.ascii	"s(melted)[2:3] <- c('Species', 'Number')\012      c"
	.ascii	"olnames <- unique(melted$Species)\012      output[["
	.ascii	"1]] = actionButton('showAll', 'Show/Hide All')\012 "
	.ascii	"     # Create the checkboxes and select them all by"
	.ascii	" default\012      output[[2]] = checkboxGroupInput("
	.ascii	"'columns', '', choices  = colnames, selected = coln"
	.ascii	"ames, inline = T)\012    }\012    return(output)\012"
	.ascii	"  })\012  \012  observeEvent(input$showAll,{\012   "
	.ascii	" if(error() != '' || is.null(resTask()))\012      r"
	.ascii	"eturn(NULL)\012    \012    data <- resTask()$result"
	.ascii	"\012    melted <- melt(data,id.vars='Time')\012    "
	.ascii	"colnames(melted)[2:3] <- c('Species', 'Number')\012"
	.ascii	"    colnames <- unique(melted$Species)\012    if (i"
	.ascii	"nput$showAll %% 2 == 0){\012      updateCheckboxGro"
	.ascii	"upInput(session=session,'columns', choices= colname"
	.ascii	"s, selected= colnames,inline = T)\012    }\012    e"
	.ascii	"lse {\012      updateCheckboxGroupInput(session=ses"
	.ascii	"sion,'columns', choices= colnames, selected= NULL,i"
	.ascii	"nline = T)\012    }\012  })\012\012#### To generate"
	.ascii	" options interface for tasks ####\012  output$choos"
	.ascii	"e_options <- renderUI({\012    # If missing input, "
	.ascii	"return to avoid error later in function\012    if(l"
	.ascii	"ength(get_selected(input$taskSelection))==0)\012   "
	.ascii	"   return(NULL)\012    else{\012      textOutput('s"
	.ascii	"election')\012    }\012    output = tagList()\012  "
	.ascii	"  selectedTask <- selection()\012    if (selectedTa"
	.ascii	"sk %in% c('Reactions','Species','Compartments', 'Gl"
	.ascii	"obal Quantities','Events','Parameters','Stoichiomet"
	.ascii	"ry')){\012      output[[1]] = ''\012    }\012    el"
	.ascii	"se if (selectedTask %in% c('Steady State','Linear N"
	.ascii	"oise Approximation')){\012      if (selectedTask =="
	.ascii	" 'Steady State'){\012        if (!is.null(inputFile"
	.ascii	"$modelData)) settingTask = CoRC::getSS(model=inputF"
	.ascii	"ile$modelData)\012        output[[1]] = splitLayout"
	.ascii	"(checkboxInput('calculateJacobian','calculate Jacob"
	.ascii	"ian', value= ifelse(is.null(inputFile$modelData), T"
	.ascii	", settingTask$calculate_jacobian)),checkboxInput("
	.ascii	"'performStabilityAnalysis','perform Stability Analy"
	.ascii	"sis', value= ifelse(is.null(inputFile$modelData), T"
	.ascii	", settingTask$perform_stability_analysis)))\012    "
	.ascii	"  }\012      else {\012        if (!is.null(inputFi"
	.ascii	"le$modelData))settingTask = CoRC::getLNA(model=inpu"
	.ascii	"tFile$modelData)\012        output[[1]] = checkboxI"
	.ascii	"nput('lnaSelection','perform Steady State Analysis'"
	.ascii	",value = ifelse(is.null(inputFile$modelData), T, se"
	.ascii	"ttingTask$perform_steady_state_analysis))\012      "
	.ascii	"}\012      output[[2]] = splitLayout(numericInput('"
	.ascii	"resolution', 'Resolution:', ifelse(is.null(inputFil"
	.ascii	"e$modelData), 1e-9, settingTask$method$resolution),"
	.ascii	" min = 1e-9, max = 1),numericInput('derivationFac',"
	.ascii	" 'Derivation Factor:', ifelse(is.null(inputFile$mod"
	.ascii	"elData), 1e-3, settingTask$method$derivation_factor"
	.ascii	"), min = 1e-3, max = 1))\012      output[[3]] = spl"
	.ascii	"itLayout(checkboxInput('useNewton','Use Newton', va"
	.ascii	"lue= ifelse(is.null(inputFile$modelData), T, settin"
	.ascii	"gTask$method$use_newton)),checkboxInput('useIntegra"
	.ascii	"tion','Use Integration', value= ifelse(is.null(inpu"
	.ascii	"tFile$modelData), T, settingTask$method$use_integra"
	.ascii	"tion)),checkboxInput('useBackIntegration','Use Back"
	.ascii	" Integration', value= ifelse(is.null(inputFile$mode"
	.ascii	"lData), F, settingTask$method$use_back_integration)"
	.ascii	"))\012      output[[4]] = actionButton('runTask', '"
	.ascii	"Run Task',icon=icon('angle-double-right'))\012     "
	.ascii	" output[[5]] = downloadButton('downloadData', 'Down"
	.ascii	"load Results')\012    }\012    else if (selectedTas"
	.ascii	"k == 'Time Course'){\012      output[[1]] = splitLa"
	.ascii	"yout(numericInput('obsTime', 'Duration [s]:', ifels"
	.ascii	"e(is.null(inputFile$modelData), 10, inputFile$setti"
	.ascii	"ngsTC$duration), min = 1, max = 1000),numericInput("
	.ascii	"'obsIntervalSize', 'Interval Size [s]:', ifelse(is."
	.ascii	"null(inputFile$modelData), 1, inputFile$settingsTC$"
	.ascii	"dt), min = 0.0001, max = 100))\012      output[[2]]"
	.ascii	" = checkboxInput('startSteady','start in Steady Sta"
	.ascii	"te', value= ifelse(is.null(inputFile$modelData), F,"
	.ascii	" inputFile$settingsTC$start_in_steady_state))\012  "
	.ascii	"    output[[3]] = selectInput('timeCourseSelection'"
	.ascii	", 'Select a Method:', choices = c('Deterministic (L"
	.ascii	"SO"
	.ascii	"DA)'='deterministic'\012                           "
	.ascii	"                                                   "
	.ascii	"         ,'Stochastic (Gibson + Bruck) '='stochasti"
	.ascii	"c'\012                                             "
	.ascii	"                                          ,'Stochas"
	.ascii	"tic (Direct method)'='directMethod'\012            "
	.ascii	"                                                   "
	.ascii	"                        ,'Stochastic (Tau leap)'='t"
	.ascii	"auLeap'\012                                        "
	.ascii	"                                               ,'St"
	.ascii	"ochastic (Adaptive SSA)'='adaptiveSA'\012          "
	.ascii	"                                                   "
	.ascii	"                          ,'Hybrid (Runge-Kutta)'='"
	.ascii	"hybrid'\012                                        "
	.ascii	"                                               ,'Hy"
	.ascii	"brid (LSODA)'='hybridLSODA'\012                    "
	.ascii	"                                                   "
	.ascii	"                #,'Hybrid (RK45)'='hybridODE45'\012"
	.ascii	"                                                   "
	.ascii	"                                    ,'SDE solver (R"
	.ascii	"I5)'='stochasticRunkeKuttaRI5')\012                "
	.ascii	"                ,selected = ifelse(is.null(inputFil"
	.ascii	"e$modelData), 'deterministic', inputFile$settingsTC"
	.ascii	"$method$method))\012      output[[4]] = actionButto"
	.ascii	"n('runTask', 'Run Task',icon=icon('angle-double-rig"
	.ascii	"ht'))\012      output[[5]] = downloadButton('downlo"
	.ascii	"adData', 'Download Results')\012    }\012    else i"
	.ascii	"f (selectedTask == 'Metabolic Control Analysis'){\012"
	.ascii	"      if (!is.null(inputFile$modelData)) settingTas"
	.ascii	"k = CoRC::getMCA(model=inputFile$modelData)\012    "
	.ascii	"  output[[1]] = checkboxInput('mcaSelection','perfo"
	.ascii	"rm Steady State Analysis',value = T)\012      outpu"
	.ascii	"t[[2]] = numericInput('modulationFactor', 'Modulati"
	.ascii	"on Factor:', ifelse(is.null(inputFile$modelData), 1"
	.ascii	"e-9, settingTask$method$modulation_factor), min = 1"
	.ascii	"e-9, max = 1)\012      output[[3]] = splitLayout(ch"
	.ascii	"eckboxInput('useReder','Use Reder', value= ifelse(i"
	.ascii	"s.null(inputFile$modelData), T, settingTask$method$"
	.ascii	"use_reder)),checkboxInput('useSmallbone','Use Small"
	.ascii	"bone', value= ifelse(is.null(inputFile$modelData), "
	.ascii	"T, settin"
	.ascii	"gTask$method$use_smallbone)))\012      output[[4]] "
	.ascii	"= actionButton('runTask', 'Run Task',icon=icon('ang"
	.ascii	"le-double-right'))\012      output[[5]] = downloadB"
	.ascii	"utton('downloadData', 'Download Results')\012    }\012"
	.ascii	"    else if (selectedTask == 'Optimization'){\012  "
	.ascii	"    output[[1]] = tabsetPanel(id = 'PE',tabPanel('P"
	.ascii	"arameters', DT::dataTableOutput('tableParameterList"
	.ascii	"')),tabPanel('Constraints', DT::dataTableOutput('ta"
	.ascii	"bleConstraintList')) )\012      output[[2]] = htmlO"
	.ascii	"utput('selectedMethod')\012      output[[3]] = acti"
	.ascii	"onButton('runTask', 'Run Task',icon=icon('angle-dou"
	.ascii	"ble-right'))\012      output[[4]] = downloadButton("
	.ascii	"'downloadData', 'Download Results')\012    }\012   "
	.ascii	" else if (selectedTask == 'Parameter Estimation'){\012"
	.ascii	"      output[[1]] = tabsetPanel(id = 'PE',tabPanel("
	.ascii	"'Parameters', DT::dataTableOutput('tableParameterLi"
	.ascii	"st')),tabPanel('Constraints', DT::dataTableOutput('"
	.ascii	"tableConstraintList')) )\012      output[[2]] = htm"
	.ascii	"lOutput('selectedMethod')\012      output[[3]] = ac"
	.ascii	"tionButton('runTask', 'Run Task',icon=icon('angle-d"
	.ascii	"ouble-right'))\012      output[[4]] = downloadButto"
	.ascii	"n('downloadData', 'Download Results')\012    }\012 "
	.ascii	"   return(output)\012  })\012  \012  ### Tree struc"
	.ascii	"ture for task selection\012  output$taskSelection <"
	.ascii	"- renderTree({ \012    structTree =list('Model'= st"
	.ascii	"ructure(list('Compartments'= structure('1',sticon='"
	.ascii	"'),'Species'= structure('2',sticon=''),'Reactions'="
	.ascii	" structure('3',sticon=''),'Global Quantities'= stru"
	.ascii	"cture('4',sticon=''),'Events'= structure('5',sticon"
	.ascii	"=''),'Parameters'= structure('6',sticon=''),'Stoich"
	.ascii	"iometry'= structure('7',sticon='')),sticon='')\012 "
	.ascii	"                    ,'Tasks'= structure(list('Stead"
	.ascii	"y State'= structure('1',sticon=''),'Time Course'= s"
	.ascii	"tructure('2',sticon=''),'Metabolic Control Analysis"
	.ascii	"'= structure('3',sticon=''),'Optimization'= structu"
	.ascii	"re('4',sticon=''),'Parameter Estimation'= structure"
	.ascii	"('5',sticon=''),'Linear Noise Approximation'= struc"
	.ascii	"ture('6',sticon='')), sticon=''))\012    attr(struc"
	.ascii	"tTree[[1]],'stopened')=TRUE \012    attr(structTree"
	.ascii	"[[2]],'stopened')=TRUE \012    structTree\012  })\012"
	.ascii	"}\012\000"
	.data
	.align	2
	.type	shinyServerString, %object
	.size	shinyServerString, 4
shinyServerString:
	.word	.LC0
	.ident	"GCC: (Ubuntu 9.4.0-1ubuntu1~20.04.2) 9.4.0"
	.section	.note.GNU-stack,"",%progbits
