Merge topic 'mumps_coverage'

c806b23 CDash now supports lots of files in coverage. So, show all files.
761d931 Do not try to run bullseye coverage if COVFILE env is empty.
5b69ce4 Update test data to match new coverage format.
1b418f1 Change GT.M Coverage Parser global
b0c07a1 Disable bullseye coverage for mumps coverage test.
0a169e6 Remove uncovered files from cache coverage data.
a7abf5e Add ability to specify more than one package directory or coverage directory.
220afca Use <TARGET_FILE> expression to run ctest so it works with Xcode and VS IDE.
62f6bce Use a script to run the test because WORKING_DIRECTORY is not in 2.8.2.
f5c5db0 Fix some warnings and a bug where it went past the length of a vector.
7955e99 Add support for Cache coverage.
a86cd33 Add virutal destructor to silence warning.
319eeb0 Add test for mumps coverage. Also refactor code to prepare for cache coverage.
72210c2 Fix line length.
dd07161 Fix warning about char* instead of const char*.
e6412e0 Add support to ctest for GTM mumps coverage.

19 files changed, 2807 insertions, 4 deletions

diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index b923136..46bdec6 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -425,6 +425,9 @@ SET(CTEST_SRCS cmCTest.cxx
   CTest/cmCTestConfigureHandler.cxx
   CTest/cmCTestCoverageCommand.cxx
   CTest/cmCTestCoverageHandler.cxx
+  CTest/cmParseMumpsCoverage.cxx
+  CTest/cmParseCacheCoverage.cxx
+  CTest/cmParseGTMCoverage.cxx
   CTest/cmParsePHPCoverage.cxx
   CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
   CTest/cmCTestGenericHandler.cxx
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index 15c02b4..81d3669 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -11,6 +11,8 @@
 ============================================================================*/
 #include "cmCTestCoverageHandler.h"
 #include "cmParsePHPCoverage.h"
+#include "cmParseGTMCoverage.h"
+#include "cmParseCacheCoverage.h"
 #include "cmCTest.h"
 #include "cmake.h"
 #include "cmMakefile.h"
@@ -373,21 +375,29 @@ int cmCTestCoverageHandler::ProcessHandler()
     }
   int file_count = 0;
   file_count += this->HandleGCovCoverage(&cont);
+  error = cont.Error;
   if ( file_count < 0 )
     {
     return error;
     }
   file_count += this->HandleTracePyCoverage(&cont);
+  error = cont.Error;
   if ( file_count < 0 )
     {
     return error;
     }
   file_count += this->HandlePHPCoverage(&cont);
+  error = cont.Error;
   if ( file_count < 0 )
     {
     return error;
     }
+  file_count += this->HandleMumpsCoverage(&cont);
   error = cont.Error;
+  if ( file_count < 0 )
+    {
+    return error;
+    }
 
   std::set<std::string> uncovered = this->FindUncoveredFiles(&cont);
 
@@ -751,6 +761,46 @@ int cmCTestCoverageHandler::HandlePHPCoverage(
     }
   return static_cast<int>(cont->TotalCoverage.size());
 }
+//----------------------------------------------------------------------
+int cmCTestCoverageHandler::HandleMumpsCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  // try gtm coverage
+  cmParseGTMCoverage cov(*cont, this->CTest);
+  std::string coverageFile = this->CTest->GetBinaryDir() +
+    "/gtm_coverage.mcov";
+  if(cmSystemTools::FileExists(coverageFile.c_str()))
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Parsing Cache Coverage: " << coverageFile
+               << std::endl);
+    cov.ReadCoverageFile(coverageFile.c_str());
+    return static_cast<int>(cont->TotalCoverage.size());
+    }
+  else
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               " Cannot find foobar GTM coverage file: " << coverageFile
+               << std::endl);
+    }
+  cmParseCacheCoverage ccov(*cont, this->CTest);
+  coverageFile = this->CTest->GetBinaryDir() +
+    "/cache_coverage.cmcov";
+  if(cmSystemTools::FileExists(coverageFile.c_str()))
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Parsing Cache Coverage: " << coverageFile
+               << std::endl);
+    ccov.ReadCoverageFile(coverageFile.c_str());
+    }
+  else
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               " Cannot find Cache coverage file: " << coverageFile
+               << std::endl);
+    }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
 
 struct cmCTestCoverageHandlerLocale
 {
@@ -1806,7 +1856,7 @@ int cmCTestCoverageHandler::HandleBullseyeCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
   const char* covfile = cmSystemTools::GetEnv("COVFILE");
-  if(!covfile)
+  if(!covfile || strlen(covfile) == 0)
     {
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, 
                " COVFILE environment variable not found, not running " 
diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h
index d3e8503..92b0b22 100644
--- a/Source/CTest/cmCTestCoverageHandler.h
+++ b/Source/CTest/cmCTestCoverageHandler.h
@@ -70,6 +70,8 @@ private:
 
   //! Handle coverage using xdebug php coverage
   int HandlePHPCoverage(cmCTestCoverageHandlerContainer* cont);
+  //! Handle coverage for mumps
+  int HandleMumpsCoverage(cmCTestCoverageHandlerContainer* cont);
 
   //! Handle coverage using Bullseye
   int HandleBullseyeCoverage(cmCTestCoverageHandlerContainer* cont);
diff --git a/Source/CTest/cmParseCacheCoverage.cxx b/Source/CTest/cmParseCacheCoverage.cxx
new file mode 100644
index 0000000..137f344
--- /dev/null
+++ b/Source/CTest/cmParseCacheCoverage.cxx
@@ -0,0 +1,220 @@
+#include "cmStandardIncludes.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "cmSystemTools.h"
+#include "cmParseCacheCoverage.h"
+#include <cmsys/Directory.hxx>
+#include <cmsys/Glob.hxx>
+
+
+cmParseCacheCoverage::cmParseCacheCoverage(
+  cmCTestCoverageHandlerContainer& cont,
+  cmCTest* ctest)
+  :cmParseMumpsCoverage(cont, ctest)
+{
+}
+
+
+bool cmParseCacheCoverage::LoadCoverageData(const char* d)
+{
+  // load all the .mcov files in the specified directory
+  cmsys::Directory dir;
+  if(!dir.Load(d))
+    {
+    return false;
+    }
+  size_t numf;
+  unsigned int i;
+  numf = dir.GetNumberOfFiles();
+  for (i = 0; i < numf; i++)
+    {
+    std::string file = dir.GetFile(i);
+    if(file != "." && file != ".."
+       && !cmSystemTools::FileIsDirectory(file.c_str()))
+      {
+      std::string path = d;
+      path += "/";
+      path += file;
+      if(cmSystemTools::GetFilenameLastExtension(path) == ".cmcov")
+        {
+        if(!this->ReadCMCovFile(path.c_str()))
+          {
+          return false;
+          }
+        }
+      }
+    }
+  return true;
+}
+
+// not currently used, but leave it in case we want it in the future
+void cmParseCacheCoverage::RemoveUnCoveredFiles()
+{
+  // loop over the coverage data computed and remove all files
+  // that only have -1 or 0 for the lines.
+  cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator ci =
+    this->Coverage.TotalCoverage.begin();
+  while(ci != this->Coverage.TotalCoverage.end())
+    {
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& v =
+      ci->second;
+    bool nothing = true;
+    for(cmCTestCoverageHandlerContainer::SingleFileCoverageVector::iterator i=
+          v.begin(); i != v.end(); ++i)
+      {
+      if(*i > 0)
+        {
+        nothing = false;
+        break;
+        }
+      }
+    if(nothing)
+      {
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "No coverage found in: " << ci->first
+                 << std::endl);
+      this->Coverage.TotalCoverage.erase(ci++);
+      }
+    else
+      {
+      ++ci;
+      }
+    }
+}
+
+bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
+                                       std::string const& line)
+{
+  std::string::size_type pos1 = 0;
+  std::string::size_type pos2 = line.find(',', 0);
+  if(pos2 == std::string::npos)
+    {
+    return false;
+    }
+  std::string arg;
+  while(pos2 != std::string::npos)
+    {
+    arg = line.substr(pos1, pos2-pos1);
+    args.push_back(arg);
+    pos1 = pos2+1;
+    pos2 = line.find(',',pos1);
+    }
+  arg = line.substr(pos1);
+  args.push_back(arg);
+  return true;
+}
+
+bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
+{
+  std::ifstream in(file);
+  if(!in)
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Can not open : "
+               << file << "\n");
+    return false;
+    }
+  std::string line;
+  std::vector<std::string> separateLine;
+  if(!cmSystemTools::GetLineFromStream(in, line))
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Empty file : "
+               << file << "  referenced in this line of cmcov data:\n"
+               "[" << line << "]\n");
+    return false;
+    }
+  separateLine.clear();
+  this->SplitString(separateLine, line);
+  if(separateLine.size() !=4 || separateLine[0] != "Routine"
+     || separateLine[1] != "Line" || separateLine[2] != "RtnLine"
+     || separateLine[3] != "Code")
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Bad first line of cmcov file : "
+               << file << "  line:\n"
+               "[" << line << "]\n");
+    }
+  std::string routine;
+  std::string filepath;
+  while(cmSystemTools::GetLineFromStream(in, line))
+    {
+    // clear out line argument vector
+    separateLine.clear();
+    // parse the comma separated line
+    this->SplitString(separateLine, line);
+    // might have more because code could have a quoted , in it
+    // but we only care about the first 3 args anyway
+    if(separateLine.size() < 4)
+      {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Bad line of cmcov file expected at least 4 found: "
+                 << separateLine.size() << " "
+                 << file << "  line:\n"
+                 "[" << line << "]\n");
+      for(std::string::size_type i = 0; i < separateLine.size(); ++i)
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,""
+                   << separateLine[1] << " ");
+        }
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\n");
+      return false;
+      }
+    // if we do not have a routine yet, then it should be
+    // the first argument in the vector
+    if(routine.size() == 0)
+      {
+      routine = separateLine[0];
+      // Find the full path to the file
+      if(!this->FindMumpsFile(routine, filepath))
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Could not find mumps file for routine: "
+                   << routine << "\n");
+        filepath = "";
+        continue; // move to next line
+        }
+      }
+    // if we have a routine name, check for end of routine
+    else
+      {
+      // Totals in arg 0 marks the end of a routine
+      if(separateLine[0].substr(0, 6) == "Totals")
+        {
+        routine = ""; // at the end of this routine
+        filepath = "";
+        continue; // move to next line
+        }
+      }
+    // if the file path was not found for the routine
+    // move to next line. We should have already warned
+    // after the call to FindMumpsFile that we did not find
+    // it, so don't report again to cut down on output
+    if(filepath.size() == 0)
+      {
+      continue;
+      }
+    // now we are ready to set the coverage from the line of data
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
+      coverageVector = this->Coverage.TotalCoverage[filepath];
+    std::string::size_type linenumber = atoi(separateLine[1].c_str()) -1;
+    int count = atoi(separateLine[2].c_str());
+    if(linenumber > coverageVector.size())
+      {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Parse error line is greater than number of lines in file: "
+                 << linenumber << " " << filepath << "\n");
+      continue; // skip setting count to avoid crash
+      }
+    // now add to count for linenumber
+    // for some reason the cache coverage adds extra lines to the
+    // end of the file in some cases. Since they do not exist, we will
+    // mark them as non executable
+    while(linenumber >= coverageVector.size())
+      {
+      coverageVector.push_back(-1);
+      }
+    coverageVector[linenumber] += count;
+    }
+  return true;
+}
diff --git a/Source/CTest/cmParseCacheCoverage.h b/Source/CTest/cmParseCacheCoverage.h
new file mode 100644
index 0000000..114eb92
--- /dev/null
+++ b/Source/CTest/cmParseCacheCoverage.h
@@ -0,0 +1,42 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc.
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#ifndef cmParseCacheCoverage_h
+#define cmParseCacheCoverage_h
+
+#include "cmParseMumpsCoverage.h"
+
+/** \class cmParseCacheCoverage
+ * \brief Parse Cache coverage information
+ *
+ * This class is used to parse Cache coverage information for
+ * mumps.
+ */
+class cmParseCacheCoverage : public cmParseMumpsCoverage
+{
+public:
+  cmParseCacheCoverage(cmCTestCoverageHandlerContainer& cont,
+    cmCTest* ctest);
+protected:
+  // implement virtual from parent
+  bool LoadCoverageData(const char* dir);
+  // remove files with no coverage
+  void RemoveUnCoveredFiles();
+  // Read a single mcov file
+  bool ReadCMCovFile(const char* f);
+  // split a string based on ,
+  bool SplitString(std::vector<std::string>& args,
+                   std::string const& line);
+};
+
+
+#endif
diff --git a/Source/CTest/cmParseGTMCoverage.cxx b/Source/CTest/cmParseGTMCoverage.cxx
new file mode 100644
index 0000000..5dfcfe5
--- /dev/null
+++ b/Source/CTest/cmParseGTMCoverage.cxx
@@ -0,0 +1,272 @@
+#include "cmStandardIncludes.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "cmSystemTools.h"
+#include "cmParseGTMCoverage.h"
+#include <cmsys/Directory.hxx>
+#include <cmsys/Glob.hxx>
+
+
+cmParseGTMCoverage::cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
+                                       cmCTest* ctest)
+  :cmParseMumpsCoverage(cont, ctest)
+{
+}
+
+
+bool cmParseGTMCoverage::LoadCoverageData(const char* d)
+{
+  // load all the .mcov files in the specified directory
+  cmsys::Directory dir;
+  if(!dir.Load(d))
+    {
+    return false;
+    }
+  size_t numf;
+  unsigned int i;
+  numf = dir.GetNumberOfFiles();
+  for (i = 0; i < numf; i++)
+    {
+    std::string file = dir.GetFile(i);
+    if(file != "." && file != ".."
+       && !cmSystemTools::FileIsDirectory(file.c_str()))
+      {
+      std::string path = d;
+      path += "/";
+      path += file;
+      if(cmSystemTools::GetFilenameLastExtension(path) == ".mcov")
+        {
+        if(!this->ReadMCovFile(path.c_str()))
+          {
+          return false;
+          }
+        }
+      }
+    }
+  return true;
+}
+
+bool cmParseGTMCoverage::ReadMCovFile(const char* file)
+{
+  std::ifstream in(file);
+  if(!in)
+    {
+    return false;
+    }
+  std::string line;
+  std::string lastfunction;
+  std::string lastroutine;
+  std::string lastpath;
+  int lastoffset = 0;
+  while(  cmSystemTools::GetLineFromStream(in, line))
+    {
+    // only look at lines that have coverage data
+    if(line.find("^ZZCOVERAGE") == line.npos)
+      {
+      continue;
+      }
+    std::string filepath;
+    std::string function;
+    std::string routine;
+    int linenumber = 0;
+    int count = 0;
+    this->ParseMCOVLine(line, routine, function, linenumber, count);
+    // skip this one
+    if(routine == "RSEL")
+      {
+      continue;
+      }
+    // no need to search the file if we just did it
+    if(function == lastfunction && lastroutine == routine)
+      {
+      if(lastpath.size())
+        {
+        this->Coverage.TotalCoverage[lastpath][lastoffset + linenumber]
+          += count;
+        }
+      else
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Can not find mumps file : "
+                   << lastroutine <<
+                   "  referenced in this line of mcov data:\n"
+                   "[" << line << "]\n");
+        }
+      continue;
+      }
+    // Find the full path to the file
+    bool found = this->FindMumpsFile(routine, filepath);
+    if(found)
+      {
+      int lineoffset;
+      if(this->FindFunctionInMumpsFile(filepath,
+                                       function,
+                                       lineoffset))
+        {
+        cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
+          coverageVector = this->Coverage.TotalCoverage[filepath];
+        coverageVector[lineoffset + linenumber] += count;
+        }
+      lastoffset = lineoffset;
+      }
+    else
+      {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Can not find mumps file : "
+               << routine << "  referenced in this line of mcov data:\n"
+                 "[" << line << "]\n");
+      }
+    lastfunction = function;
+    lastroutine = routine;
+    lastpath = filepath;
+    }
+  return true;
+}
+
+bool cmParseGTMCoverage::FindFunctionInMumpsFile(std::string const& filepath,
+                                                 std::string const& function,
+                                                 int& lineoffset)
+{
+  std::ifstream in(filepath.c_str());
+  if(!in)
+    {
+    return false;
+    }
+  std::string line;
+  int linenum = 0;
+  while(  cmSystemTools::GetLineFromStream(in, line))
+    {
+    std::string::size_type pos = line.find(function.c_str());
+    if(pos == 0)
+      {
+      char nextchar = line[function.size()];
+      if(nextchar == ' ' || nextchar == '(')
+        {
+        lineoffset = linenum;
+        return true;
+        }
+      }
+    if(pos == 1)
+      {
+      char prevchar = line[0];
+      char nextchar = line[function.size()+1];
+      if(prevchar == '%' && (nextchar == ' ' || nextchar == '('))
+        {
+        lineoffset = linenum;
+        return true;
+        }
+      }
+    linenum++; // move to next line count
+    }
+  lineoffset = 0;
+  cmCTestLog(this->CTest, ERROR_MESSAGE,
+             "Could not find entry point : "
+             << function << " in " << filepath << "\n");
+  return false;
+}
+
+bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
+                                       std::string& routine,
+                                       std::string& function,
+                                       int& linenumber,
+                                       int& count)
+{
+  // this method parses lines from the .mcov file
+  // each line has ^COVERAGE(...) in it, and there
+  // are several varients of coverage lines:
+  //
+  // ^COVERAGE("DIC11","PR1",0)="2:0:0:0"
+  //          ( file  , entry, line ) = "number_executed:timing_info"
+  // ^COVERAGE("%RSEL","SRC")="1:0:0:0"
+  //          ( file  , entry ) = "number_executed:timing_info"
+  // ^COVERAGE("%RSEL","init",8,"FOR_LOOP",1)=1
+  //          ( file  , entry, line, IGNORE ) =number_executed
+  std::vector<cmStdString> args;
+  std::string::size_type pos = line.find('(', 0);
+  // if no ( is found, then return line has no coverage
+  if(pos == std::string::npos)
+    {
+    return false;
+    }
+  std::string arg;
+  bool done = false;
+  // separate out all of the comma separated arguments found
+  // in the COVERAGE(...) line
+  while(line[pos] && !done)
+    {
+    // save the char we are looking at
+    char cur = line[pos];
+    // , or ) means end of argument
+    if(cur == ',' || cur == ')')
+      {
+      // save the argument into the argument vector
+      args.push_back(arg);
+      // start on a new argument
+      arg = "";
+      // if we are at the end of the ), then finish while loop
+      if(cur == ')')
+        {
+        done = true;
+        }
+      }
+    else
+      {
+      // all chars except ", (, and % get stored in the arg string
+      if(cur != '\"' && cur != '(' && cur != '%')
+        {
+        arg.append(1, line[pos]);
+        }
+      }
+    // move to next char
+    pos++;
+    }
+  // now parse the right hand side of the =
+  pos = line.find('=');
+  // no = found, this is an error
+  if(pos == line.npos)
+    {
+    return false;
+    }
+  pos++; // move past =
+
+  // if the next positing is not a ", then this is a
+  // COVERAGE(..)=count line and turn the rest of the string
+  // past the = into an integer and set it to count
+  if(line[pos] != '\"')
+    {
+    count = atoi(line.substr(pos).c_str());
+    }
+  else
+    {
+    // this means line[pos] is a ", and we have a
+    // COVERAGE(...)="1:0:0:0" type of line
+    pos++; // move past "
+    // find the first : past the "
+    std::string::size_type pos2 = line.find(':', pos);
+    // turn the string between the " and the first : into an integer
+    // and set it to count
+    count = atoi(line.substr(pos, pos2-pos).c_str());
+    }
+  // less then two arguments is an error
+  if(args.size() < 2)
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error parsing mcov line: [" << line << "]\n");
+    return false;
+    }
+  routine = args[0]; // the routine is the first argument
+  function = args[1]; // the function in the routine is the second
+  // in the two argument only format
+  // ^COVERAGE("%RSEL","SRC"), the line offset is 0
+  if(args.size() == 2)
+    {
+    linenumber = 0;
+    }
+  else
+    {
+    // this is the format for this line
+    // ^COVERAGE("%RSEL","SRC",count)
+    linenumber = atoi(args[2].c_str());
+    }
+  return true;
+}
diff --git a/Source/CTest/cmParseGTMCoverage.h b/Source/CTest/cmParseGTMCoverage.h
new file mode 100644
index 0000000..c6d7ef9
--- /dev/null
+++ b/Source/CTest/cmParseGTMCoverage.h
@@ -0,0 +1,49 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc.
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#ifndef cmParseGTMCoverage_h
+#define cmParseGTMCoverage_h
+
+#include "cmParseMumpsCoverage.h"
+
+/** \class cmParseGTMCoverage
+ * \brief Parse GTM coverage information
+ *
+ * This class is used to parse GTM coverage information for
+ * mumps.
+ */
+class cmParseGTMCoverage : public cmParseMumpsCoverage
+{
+public:
+  cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
+    cmCTest* ctest);
+protected:
+  // implement virtual from parent
+  bool LoadCoverageData(const char* dir);
+  // Read a single mcov file
+  bool ReadMCovFile(const char* f);
+  // find out what line in a mumps file (filepath) the given entry point
+  // or function is.  lineoffset is set by this method.
+  bool FindFunctionInMumpsFile(std::string const& filepath,
+                               std::string const& function,
+                               int& lineoffset);
+  // parse a line from a .mcov file, and fill in the
+  // routine, function, linenumber and coverage count
+  bool ParseMCOVLine(std::string const& line,
+                 std::string& routine,
+                 std::string& function,
+                 int& linenumber,
+                 int& count);
+};
+
+
+#endif
diff --git a/Source/CTest/cmParseMumpsCoverage.cxx b/Source/CTest/cmParseMumpsCoverage.cxx
new file mode 100644
index 0000000..37e8bd0
--- /dev/null
+++ b/Source/CTest/cmParseMumpsCoverage.cxx
@@ -0,0 +1,165 @@
+#include "cmStandardIncludes.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "cmSystemTools.h"
+#include "cmParseGTMCoverage.h"
+#include <cmsys/Directory.hxx>
+#include <cmsys/Glob.hxx>
+
+
+cmParseMumpsCoverage::cmParseMumpsCoverage(
+  cmCTestCoverageHandlerContainer& cont,
+  cmCTest* ctest)
+  :Coverage(cont), CTest(ctest)
+{
+}
+
+cmParseMumpsCoverage::~cmParseMumpsCoverage()
+{
+}
+
+bool cmParseMumpsCoverage::ReadCoverageFile(const char* file)
+{
+  // Read the gtm_coverage.mcov file, that has two lines of data:
+  // packages:/full/path/to/Vista/Packages
+  // coverage_dir:/full/path/to/dir/with/*.mcov
+  std::ifstream in(file);
+  if(!in)
+    {
+    return false;
+    }
+  std::string line;
+  while(cmSystemTools::GetLineFromStream(in, line))
+    {
+    std::string::size_type pos = line.find(':', 0);
+    std::string packages;
+    if(pos != std::string::npos)
+      {
+      std::string type = line.substr(0, pos);
+      std::string path = line.substr(pos+1);
+      if(type == "packages")
+        {
+        this->LoadPackages(path.c_str());
+        }
+      else if(type == "coverage_dir")
+        {
+        this->LoadCoverageData(path.c_str());
+        }
+      else
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Parse Error in Mumps coverage file :\n"
+                   << file <<
+                   "\ntype: [" << type << "]\npath:[" << path << "]\n"
+                   "input line: [" << line << "]\n");
+        }
+      }
+    }
+  return true;
+}
+
+void cmParseMumpsCoverage::InitializeMumpsFile(std::string& file)
+{
+  // initialize the coverage information for a given mumps file
+  std::ifstream in(file.c_str());
+  if(!in)
+    {
+    return;
+    }
+  std::string line;
+  cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
+    coverageVector = this->Coverage.TotalCoverage[file];
+  if(!cmSystemTools::GetLineFromStream(in, line))
+    {
+    return;
+    }
+  // first line of a .m file can never be run
+  coverageVector.push_back(-1);
+  while( cmSystemTools::GetLineFromStream(in, line) )
+    {
+    // putting in a 0 for a line means it is executable code
+    // putting in a -1 for a line means it is not executable code
+    int val = -1; // assume line is not executable
+    bool found = false;
+    std::string::size_type i = 0;
+    // (1) Search for the first whitespace or semicolon character on a line.
+    //This will skip over labels if the line starts with one, or will simply
+    //be the first character on the line for non-label lines.
+    for(; i < line.size(); ++i)
+      {
+      if(line[i] == ' ' || line[i] == '\t' || line[i] == ';')
+        {
+        found = true;
+        break;
+        }
+      }
+    if(found)
+      {
+      // (2) If the first character found above is whitespace then continue the
+      // search for the first following non-whitespace character.
+      if(line[i] == ' ' || line[i] == '\t')
+        {
+        while(i < line.size() && (line[i] == ' ' || line[i] == '\t'))
+          {
+          i++;
+          }
+        }
+      // (3) If the character found is not a semicolon then the line counts for
+      // coverage.
+      if(i < line.size() && line[i] != ';')
+        {
+        val = 0;
+        }
+      }
+    coverageVector.push_back(val);
+    }
+}
+
+bool cmParseMumpsCoverage::LoadPackages(const char* d)
+{
+  cmsys::Glob glob;
+  glob.RecurseOn();
+  std::string pat = d;
+  pat += "/*.m";
+  glob.FindFiles(pat.c_str());
+  std::vector<std::string>& files = glob.GetFiles();
+  std::vector<std::string>::iterator fileIt;
+  for ( fileIt = files.begin(); fileIt != files.end();
+        ++ fileIt )
+    {
+    std::string name = cmSystemTools::GetFilenameName(*fileIt);
+    this->RoutineToDirectory[name.substr(0, name.size()-2)] = *fileIt;
+    // initialze each file, this is left out until CDash is fixed
+    // to handle large numbers of files
+    this->InitializeMumpsFile(*fileIt);
+    }
+  return true;
+}
+
+bool cmParseMumpsCoverage::FindMumpsFile(std::string const& routine,
+                                         std::string& filepath)
+{
+  std::map<cmStdString, cmStdString>::iterator i =
+    this->RoutineToDirectory.find(routine);
+  if(i != this->RoutineToDirectory.end())
+    {
+    filepath = i->second;
+    return true;
+    }
+  else
+    {
+    // try some alternate names
+    const char* tryname[] = {"GUX", "GTM", "ONT", 0};
+    for(int k=0; tryname[k] != 0; k++)
+      {
+      std::string routine2 = routine + tryname[k];
+      i = this->RoutineToDirectory.find(routine2);
+      if(i != this->RoutineToDirectory.end())
+        {
+        filepath = i->second;
+        return true;
+        }
+      }
+    }
+  return false;
+}
diff --git a/Source/CTest/cmParseMumpsCoverage.h b/Source/CTest/cmParseMumpsCoverage.h
new file mode 100644
index 0000000..c1effa7
--- /dev/null
+++ b/Source/CTest/cmParseMumpsCoverage.h
@@ -0,0 +1,52 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc.
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#ifndef cmParseMumpsCoverage_h
+#define cmParseMumpsCoverage_h
+
+#include "cmStandardIncludes.h"
+#include "cmCTestCoverageHandler.h"
+
+/** \class cmParseMumpsCoverage
+ * \brief Parse Mumps coverage information
+ *
+ * This class is used as the base class for Mumps coverage
+ * parsing.
+ */
+class cmParseMumpsCoverage
+{
+public:
+  cmParseMumpsCoverage(cmCTestCoverageHandlerContainer& cont,
+    cmCTest* ctest);
+  virtual ~cmParseMumpsCoverage();
+  // This is the toplevel coverage file locating the coverage files
+  // and the mumps source code package tree.
+  bool ReadCoverageFile(const char* file);
+protected:
+  // sub classes will use this to
+  // load all coverage files found in the given directory
+  virtual bool LoadCoverageData(const char* d) = 0;
+  // search the package directory for mumps files and fill
+  // in the RoutineToDirectory map
+  bool LoadPackages(const char* dir);
+  // initialize the coverage information for a single mumps file
+  void InitializeMumpsFile(std::string& file);
+  // Find mumps file for routine
+  bool FindMumpsFile(std::string const& routine,
+                     std::string& filepath);
+protected:
+  std::map<cmStdString, cmStdString> RoutineToDirectory;
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
+
+#endif
diff --git a/Source/CTest/cmParsePHPCoverage.h b/Source/CTest/cmParsePHPCoverage.h
index ce5741d..d50a83c 100644
--- a/Source/CTest/cmParsePHPCoverage.h
+++ b/Source/CTest/cmParsePHPCoverage.h
@@ -37,9 +37,6 @@ private:
   bool ReadInt(std::ifstream& in, int& v);
   bool ReadCoverageArray(std::ifstream& in, cmStdString const&);
   bool ReadUntil(std::ifstream& in, char until);
-  typedef std::map<int, int> FileLineCoverage;
-  std::map<cmStdString, FileLineCoverage> FileToCoverage;
-  std::map<int, int> FileCoverage;
   cmCTestCoverageHandlerContainer& Coverage;
   cmCTest* CTest;
 };
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index c0b7cd6..3f5dd2c 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -1708,6 +1708,42 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     PASS_REGULAR_EXPRESSION
       "Reading ctest configuration file: ${CTEST_TEST_ESCAPED_BINARY_DIR}.Tests.CTestTestConfigFileInBuildDir2.CTestConfig.cmake")
 
+  # test coverage for mumps
+  # create a MumpsCoverage dir in the binary tree under Testing to
+  # avoid the .NoDartCoverage files in the cmake testing tree
+  configure_file(
+     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.tcl.in"
+     "${CMake_BINARY_DIR}/Testing/MumpsCoverage/DartConfiguration.tcl")
+  configure_file(
+     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/gtm_coverage.mcov.in"
+     "${CMake_BINARY_DIR}/Testing/MumpsCoverage/gtm_coverage.mcov")
+  file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
+    DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCoverage")
+  add_test(NAME CTestGTMCoverage
+    COMMAND cmake -E chdir
+    ${CMake_BINARY_DIR}/Testing/MumpsCoverage
+    $<TARGET_FILE:ctest> -T Coverage --debug)
+  set_tests_properties(CTestGTMCoverage PROPERTIES
+      PASS_REGULAR_EXPRESSION
+      "Process file.*XINDEX.m.*Total LOC:.*127.*Percentage Coverage: 85.83.*"
+      ENVIRONMENT COVFILE=)
+
+  configure_file(
+     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in"
+     "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/DartConfiguration.tcl")
+  configure_file(
+    "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/cache_coverage.cmcov.in"
+    "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/cache_coverage.cmcov")
+  file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
+    DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage")
+  add_test(NAME CTestCacheCoverage
+    COMMAND cmake -E chdir
+    ${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage
+    $<TARGET_FILE:ctest> -T Coverage --debug)
+  set_tests_properties(CTestCacheCoverage PROPERTIES
+      PASS_REGULAR_EXPRESSION
+      "Process file.*XINDEX.m.*Total LOC:.*125.*Percentage Coverage: 85.60.*"
+      ENVIRONMENT COVFILE=)
   # Use macro, not function so that build can still be driven by CMake 2.4.
   # After 2.6 is required, this could be a function without the extra 'set'
   # calls.
diff --git a/Tests/MumpsCoverage/.gitattributes b/Tests/MumpsCoverage/.gitattributes
new file mode 100644
index 0000000..b680612
--- /dev/null
+++ b/Tests/MumpsCoverage/.gitattributes
@@ -0,0 +1,2 @@
+*.cmcov  -crlf  -whitespace
+*.mcov   -crlf  -whitespace
diff --git a/Tests/MumpsCoverage/Accounts_ReceivableTest.cmcov b/Tests/MumpsCoverage/Accounts_ReceivableTest.cmcov
new file mode 100644
index 0000000..c3b3342
--- /dev/null
+++ b/Tests/MumpsCoverage/Accounts_ReceivableTest.cmcov
@@ -0,0 +1,304 @@
+Routine,Line,RtnLine,Code

+DDIOL,1,0,"DDIOL ;SFISC/MKO-THE LOADER ;1:53 PM  12 Sep 1995"

+,2,0," ;;22.0;VA FileMan;;Mar 30, 1999"

+,3,0," ;Per VHA Directive 10-93-142, this routine should not be modified."

+,4,0," ;"

+,5,0,"EN(A,G,FMT) ;Write the text contained in local array A or global array G"

+,6,0," ;If one string passed, use format FMT"

+,7,0," N %,Y,DINAKED"

+,8,0," S DINAKED=$$LGR^%ZOSV"

+,9,0," ;"

+,10,0," S:'$D(A) A="""""

+,11,0," I $G(A)="""",$D(A)<9,$G(FMT)="""",$G(G)'?1""^""1A.7AN,$G(G)'?1""^""1A.7AN1""("".E1"")"" Q"

+,12,0," ;"

+,13,0," G:$D(DDS) SM"

+,14,0," G:$D(DIQUIET) LD"

+,15,0," ;"

+,16,0," N F,I,S"

+,17,0," I $D(A)=1,$G(G)="""" D"

+,18,0," . S F=$S($G(FMT)]"""":FMT,1:""!"")"

+,19,0," . W @F,A"

+,20,0," ;"

+,21,0," E  I $D(A)>9 S I=0 F  S I=$O(A(I)) Q:I'=+$P(I,""E"")  D"

+,22,0," . S F=$G(A(I,""F""),""!"") S:F="""" F=""?0"""

+,23,0," . W @F,$G(A(I))"

+,24,0," ;"

+,25,0," E  S I=0 F  S I=$O(@G@(I)) Q:I'=+$P(I,""E"")  D"

+,26,0," . S S=$G(@G@(I,0),$G(@G@(I)))"

+,27,0," . S F=$G(@G@(I,""F""),""!"") S:F="""" F=""?0"""

+,28,0," . W @F,S"

+,29,0," ;"

+,30,0," I DINAKED]"""" S DINAKED=$S(DINAKED["""""""""""":$O(@DINAKED),1:$D(@DINAKED))"

+,31,0," Q"

+,32,0," ;"

+,33,0,"LD ;Load text into ^TMP"

+,34,0," N I,N,T"

+,35,0," S T=$S($G(DDIOLFLG)[""H"":""DIHELP"",1:""DIMSG"")"

+,36,0," S N=$O(^TMP(T,$J,"" ""),-1)"

+,37,0," ;"

+,38,0," I $D(A)=1,$G(G)="""" D"

+,39,0," . D LD1(A,$S($G(FMT)]"""":FMT,1:""!""))"

+,40,0," ;"

+,41,0," E  I $D(A)>9 S I=0 F  S I=$O(A(I)) Q:I'=+$P(I,""E"")  D"

+,42,0," . D LD1($G(A(I)),$G(A(I,""F""),""!""))"

+,43,0," ;"

+,44,0," E  S I=0 F  S I=$O(@G@(I)) Q:I'=+$P(I,""E"")  D"

+,45,0," . D LD1($G(@G@(I),$G(@G@(I,0))),$G(@G@(I,""F""),""!""))"

+,46,0," ;"

+,47,0," K:'N @T S:N @T=N"

+,48,0," I DINAKED]"""" S DINAKED=$S(DINAKED["""""""""""":$O(@DINAKED),1:$D(@DINAKED))"

+,49,0," Q"

+,50,0," ;"

+,51,0,"LD1(S,F) ;Load string S, with format F"

+,52,0," ;In: N and T"

+,53,0," N C,J,L"

+,54,0," S:S[$C(7) S=$TR(S,$C(7),"""")"

+,55,0," F J=1:1:$L(F,""!"")-1 S N=N+1,^TMP(T,$J,N)="""""

+,56,0," S:'N N=1"

+,57,0," S:F[""?"" @(""C=""_$P(F,""?"",2))"

+,58,0," S L=$G(^TMP(T,$J,N))"

+,59,0," S ^TMP(T,$J,N)=L_$J("""",$G(C)-$L(L))_S"

+,60,0," Q"

+,61,0," ;"

+,62,0,"SM ;Print text in ScreenMan's Command Area"

+,63,0," I $D(DDSID),$D(DTOUT)!$D(DUOUT) G SMQ"

+,64,0," N DDIOL"

+,65,0," S DDIOL=1"

+,66,0," ;"

+,67,0," I $D(A)=1&($G(G)="""")!($D(A)>9) D"

+,68,0," . D MSG^DDSMSG(.A,"""",$G(FMT))"

+,69,0," E  I $D(@G@(+$O(@G@(0)),0))#2 D"

+,70,0," . D WP^DDSMSG(G)"

+,71,0," E  D HLP^DDSMSG(G)"

+,72,0," ;"

+,73,0,"SMQ I DINAKED]"""" S DINAKED=$S(DINAKED["""""""""""":$O(@DINAKED),1:$D(@DINAKED))"

+,74,0," Q"

+Totals for DDIOL,,0,

+XINDEX,1,0,"XINDEX ;ISC/REL,GFT,GRK,RWF - INDEX & CROSS-REFERENCE ;08/04/08  13:19"

+,2,1," ;;7.3;TOOLKIT;**20,27,48,61,66,68,110,121,128**;Apr 25, 1995;Build 1"

+,3,0," ; Per VHA Directive 2004-038, this routine should not be modified."

+,4,1," G ^XINDX6"

+,5,107216,"SEP F I=1:1 S CH=$E(LIN,I) D QUOTE:CH=Q Q:"" ""[CH"

+,6,107216," S ARG=$E(LIN,1,I-1) S:CH="" "" I=I+1 S LIN=$E(LIN,I,999) Q"

+,7,36371,"QUOTE F I=I+1:1 S CH=$E(LIN,I) Q:CH=""""!(CH=Q)"

+,8,36371," Q:CH]""""  S ERR=6 G ^XINDX1"

+,9,0,"ALIVE ;enter here from taskman"

+,10,1," D SETUP^XINDX7 ;Get ready to process"

+,11,468,"A2 S RTN=$O(^UTILITY($J,RTN)) G ^XINDX5:RTN="""""

+,12,467," S INDLC=(RTN?1""|""1.4L.NP) D LOAD:'INDLC"

+,13,467," I $D(ZTQUEUED),$$S^%ZTLOAD S RTN=""~"",IND(""QUIT"")=1,ZTSTOP=1 G A2"

+,14,467," I 'INDDS,INDLC W !!?10,""Data Dictionaries"",! S INDDS=1"

+,15,467," D BEG"

+,16,467," G A2"

+,17,0," ;"

+,18,467,"LOAD S X=RTN,XCNP=0,DIF=""^UTILITY(""_$J_"",1,RTN,0,"" X ^%ZOSF(""TEST"") Q:'$T  X ^%ZOSF(""LOAD"") S ^UTILITY($J,1,RTN,0,0)=XCNP-1"

+,19,467," I $D(^UTILITY($J,1,RTN,0,0)) S ^UTILITY($J,1,RTN,""RSUM"")=""B""_$$SUMB^XPDRSUM($NA(^UTILITY($J,1,RTN,0)))"

+,20,467," Q"

+,21,0,"BEG ;"

+,22,467," S %=INDLC*5 W:$X+10+%>IOM ! W RTN,$J("""",10+%-$L(RTN))"

+,23,467," S (IND(""DO""),IND(""SZT""),IND(""SZC""),LABO)=0,LC=$G(^UTILITY($J,1,RTN,0,0))"

+,24,467," I LC="""" W !,"">>>Routine '"",RTN,""' not found <<<"",! Q"

+,25,467," S TXT="""",LAB=$P(^UTILITY($J,1,RTN,0,1,0),"" "") I RTN'=$P(LAB,""("") D E^XINDX1(17)"

+,26,467," I 'INDLC,LAB[""("" D E^XINDX1(55) S LAB=$P(LAB,""("")"

+,27,0," ;if M routine(not compiled template or DD) and has more than 2 lines, check lines 1 & 2"

+,28,467," I 'INDLC,LC>2 D"

+,29,467," . N LABO S LABO=1"

+,30,467," . S LIN=$G(^UTILITY($J,1,RTN,0,1,0)),TXT=1"

+,31,0," . ;check 1st line (site/dev - ) patch 128"

+,32,467," . I $P(LIN,"";"",2,4)'?.E1""/"".E.1""-"".E D E^XINDX1(62)"

+,33,467," . S LIN=$G(^UTILITY($J,1,RTN,0,2,0)),TXT=2"

+,34,0," . ;check 2nd line (;;nn.nn[TV]nn;package;.anything)"

+,35,467," . I $P(LIN,"";"",3,99)'?1.2N1"".""1.2N.1(1""T"",1""V"").2N1"";""1A.AP1"";"".E D E^XINDX1(44) ;patch 121"

+,36,467," . I $L(INP(11)) X INP(11) ;Version number check"

+,37,467," . I $L(INP(12)) X INP(12) ;Patch number check"

+,38,467,"B5 F TXT=1:1:LC S LIN=^UTILITY($J,1,RTN,0,TXT,0),LN=$L(LIN),IND(""SZT"")=IND(""SZT"")+LN+2 D LN,ST ;Process Line"

+,39,467," S LAB="""",LABO=0,TXT=0,^UTILITY($J,1,RTN,0)=IND(""SZT"")_""^""_LC_""^""_IND(""SZC"")"

+,40,467," I IND(""SZT"")>INP(""MAX""),'INDLC S ERR=35,ERR(1)=IND(""SZT"") D ^XINDX1"

+,41,467," I IND(""SZT"")-IND(""SZC"")>INP(""CMAX""),'INDLC S ERR=58,ERR(1)=IND(""SZT"")-IND(""SZC"") D ^XINDX1"

+,42,467," D POSTRTN"

+,43,467," Q"

+,44,0," ;Proccess one line, LN = Length, LIN = Line."

+,45,44620,"LN K V S (ARG,GRB,IND(""COM""),IND(""DOL""),IND(""F""))="""",X=$P(LIN,"" "")"

+,46,44620," I '$L(X) S LABO=LABO+1 G CD"

+,47,5073," S (IND(""COM""),LAB)=$P(X,""(""),ARG=$P($P(X,""("",2),"")""),LABO=0,IND(""PP"")=X?1.8E1""("".E1"")"""

+,48,5073," D:$L(ARG) NE^XINDX3 ;Process formal parameters as New list."

+,49,5073," I 'INDLC,'$$VT^XINDX2(LAB) D E^XINDX1($S(LAB=$$CASE^XINDX52(LAB):37,1:55)) ;Check for bad labels"

+,50,5073," I $D(^UTILITY($J,1,RTN,""T"",LAB)) D E^XINDX1(15) G CD ;DUP label"

+,51,5073," S ^UTILITY($J,1,RTN,""T"",LAB)="""""

+,52,44620,"CD I LN>245 D:'(LN=246&($E(RTN,1,3)=""|dd"")) E^XINDX1(19) ;patch 119"

+,53,44620," D:LIN'?1.ANP E^XINDX1(18)"

+,54,44620," S LIN=$P(LIN,"" "",2,999),IND(""LCC"")=1"

+,55,44620," I LIN="""" D E^XINDX1(42) Q  ;Blank line ;p110"

+,56,44620," S I=0 ;Watch the scope of I, counts dots"

+,57,44620," I "" .""[$E(LIN) D  S X=$L($E(LIN,1,I),""."")-1,LIN=$E(LIN,I,999)"

+,58,10770," . F I=1:1:245 Q:"". ""'[$E(LIN,I)"

+,59,10770," . Q"

+,60,0," ;check dots against Do level IND(""DO""), IND(""DOL"")=dot level"

+,61,44620," D:'I&$G(IND(""DO1"")) E^XINDX1(51) S IND(""DO1"")=0 S:'I IND(""DO"")=0"

+,62,44620," I I D:X>IND(""DO"") E^XINDX1(51) S (IND(""DO""),IND(""DOL""))=X"

+,63,0," ;Count Comment lines, skip ;; lines"

+,64,44620," I $E(LIN)="";"",$E(LIN,2)'="";"" S IND(""SZC"")=IND(""SZC"")+$L(LIN) ;p110"

+,65,0," ;Process commands on line."

+,66,116081,"EE I LIN="""" D ^XINDX2 Q"

+,67,71461," S COM=$E(LIN),GK="""",ARG="""""

+,68,71461," I COM="";"" S LIN="""" G EE ;p110"

+,69,54870," I COM="" "" S ERR=$S(LIN?1."" "":13,1:0),LIN=$S(ERR:"""",1:$E(LIN,2,999)) D:ERR ^XINDX1 G EE"

+,70,53608," D SEP"

+,71,53608," S CM=$P(ARG,"":"",1),POST=$P(ARG,"":"",2,999),IND(""COM"")=IND(""COM"")_$C(9)_COM,ERR=48"

+,72,53608," D:ARG["":""&(POST']"""") ^XINDX1 S:POST]"""" GRB=GRB_$C(9)_POST,IND(""COM"")=IND(""COM"")_"":"""

+,73,0," ;SAC now allows lowercase commands"

+,74,53608," I CM?.E1L.E S CM=$$CASE^XINDX52(CM),COM=$E(CM) ;I IND(""LCC"") S IND(""LCC"")=0 D E^XINDX1(47)"

+,75,53608," I CM="""" D E^XINDX1(21) G EE ;Missing command"

+,76,53608," S CX=$G(IND(""CMD"",CM)) I CX="""" D  G:CX="""" EE"

+,77,0," . I $E(CM)=""Z"" S CX=""^Z"" Q  ;Proccess Z commands"

+,78,0," . D E^XINDX1(1) S LIN="""" Q"

+,79,53608," S CX=$P(CX,""^"",2,9)"

+,80,53608," D SEP I '$L(LIN),CH="" "" D E^XINDX1(13) ;trailing space"

+,81,53608," I ARG="""",""CGJMORSUWX""[COM S ERR=49 G ^XINDX1"

+,82,53608," I CX>0 D E^XINDX1(CX) S CX="""""

+,83,53608," D:$L(CX) @CX S:ARG'="""" GRB=GRB_$C(9)_ARG G EE"

+,84,0,"B S ERR=25 G ^XINDX1"

+,85,0,"C S ERR=29 G ^XINDX1"

+,86,0,"D G DG1^XINDX4"

+,87,0,"E Q:ARG=""""  S ERR=7 G ^XINDX1"

+,88,1559,"F G:ARG]"""" FR^XINDX4 S IND(""F"")=1 Q"

+,89,1932,"G G DG^XINDX4"

+,90,11,"H Q:ARG'=""""  S ERR=32 G ^XINDX1"

+,91,0,"J S ERR=36,ARG="""" G ^XINDX1"

+,92,2218,"K S ERR=$S(ARG?1""("".E:22,ARG?."" "":23,1:0) D:ERR ^XINDX1"

+,93,2218," G KL^XINDX3"

+,94,259,"L G LO^XINDX4"

+,95,30,"M G S^XINDX3"

+,96,1721,"N G NE^XINDX3"

+,97,0,"O S ERR=34 D ^XINDX1,O^XINDX3 Q"

+,98,7762,"Q Q:ARG=""""  G Q^XINDX4"

+,99,85,"R S RDTIME=0 G RD^XINDX3"

+,100,17549,"S G S^XINDX3"

+,101,0,"TR Q  ;What to process. p110"

+,102,72,"U S ARG=$P(ARG,"":"") Q"

+,103,0,"V S ARG="""",ERR=20 G ^XINDX1"

+,104,4584,"W G WR^XINDX4"

+,105,220,"X G XE^XINDX4"

+,106,0,"Z S ERR=2 D ^XINDX1 G ZC^XINDX4"

+,107,0," ;"

+,108,0," ;Save off items from line."

+,109,44620,"ST S R=LAB_$S(LABO:""+""_LABO,1:"""")"

+,110,0," ;Local variable, Global, Marked Items, Naked global, Internal ref, eXternal ref., Tag ref."

+,111,44620," S LOC="""" F  S LOC=$O(V(LOC)),S="""" Q:LOC=""""  F  S S=$O(V(LOC,S)) Q:S=""""  D SET"

+,112,44620," S ^UTILITY($J,1,RTN,""COM"",TXT)=IND(""COM"")"

+,113,44620," Q"

+,114,0," ;"

+,115,85079,"SET I V(LOC,S)]"""" F %=""!"",""~"" I V(LOC,S)[%,$G(^UTILITY($J,1,RTN,LOC,S))'[% S ^(S)=$G(^(S))_%"

+,116,85079," S %=0"

+,117,86891,"SE2 S ARG=$G(^UTILITY($J,1,RTN,LOC,S,%)) I $L(ARG)>230 S %=%+1 G SE2"

+,118,85079," S ^UTILITY($J,1,RTN,LOC,S,%)=ARG_R_V(LOC,S)_"","""

+,119,85079," Q"

+,120,0," ;"

+,121,0,"POSTRTN ;Do more overall checking"

+,122,467," N V,E,T,T1,T2"

+,123,467," S T="""" ;Check for missing Labels"

+,124,467," F  S T=$O(^UTILITY($J,1,RTN,""I"",T)),T2=T Q:T=""""  S T1=$G(^(T,0)) D"

+,125,2091," . Q:$E(T2,1,2)=""@("""

+,126,2044," . S:$E(T2,1,2)=""$$"" T2=$E(T2,3,99)"

+,127,2044," . I T2]"""",'$D(^UTILITY($J,1,RTN,""T"",$P(T2,""+"",1))) D"

+,128,0," . . F I=1:1:$L(T1,"","")-1 S LAB=$P(T1,"","",I),LABO=+$P(LAB,""+"",2),LAB=$P(LAB,""+""),E=14,E(1)=T D E^XINDX1(.E)"

+,129,0," . . Q"

+,130,2044," . Q"

+,131,467," S LAB="""",LABO=0 ;Check for valid label names"

+,132,467," I 'INDLC F  S LAB=$O(^UTILITY($J,1,RTN,""T"",LAB)) Q:LAB=""""  D"

+,133,5073," . I '$$VA^XINDX2(LAB) D E^XINDX1(55) Q"

+,134,5073," . D:'$$VT^XINDX2(LAB) E^XINDX1(37)"

+,135,5073," . Q"

+,136,467," S LAB="""",LABO=0 ;Check for valid variable names."

+,137,467," F  S LAB=$O(^UTILITY($J,1,RTN,""L"",LAB)) Q:LAB=""""  D"

+,138,15909," . D VLNF^XINDX3($P(LAB,""(""))"

+,139,15909," . Q"

+,140,467," Q"

+,141,0," ;"

+,142,0,"QUICK ;Quick, Just get a routine an print the results"

+,143,0," D QUICK^XINDX6()"

+,144,0," Q"

+Totals for XINDEX,,2446443,

+XINDX1,1,0,"XINDX1 ;ISC/REL,GRK,RWF - ERROR ROUTINE ;08/05/08  13:59"

+,2,2," ;;7.3;TOOLKIT;**20,61,66,68,110,121,128**;Apr 25, 1995;Build 1"

+,3,0," ; Per VHA Directive 2004-038, this routine should not be modified."

+,4,2," G A"

+,5,0,"E(ERR) ;"

+,6,75,"A N %,%1 ;TXT is the line of the error."

+,7,75," S ERTX=LAB_$S(LABO:""+""_LABO,1:"""")_$C(9),%1=$T(ERROR+ERR),ERTX=ERTX_$S(ERR:$P(%1,"";"",4,9),1:ERR) ;p110"

+,8,75," I ERTX[""|"" F %=1:1 S ERTX=$P(ERTX,""|"")_$S($D(ERR(%)):ERR(%),1:""??"")_$P(ERTX,""|"",%+1,99) Q:ERTX'[""|"""

+,9,75,"B I $P(%1,"";"",3)]"""" D  Q:%1]""""  ;Don't flag kernel doing kernel."

+,10,0," . S %1=$P(%1,"";"",3)"

+,11,0," . F  Q:RTN[$P(%1,"","")  S %1=$P(%1,"","",2,99) ;quit if RTN[%1 or null."

+,12,0," . Q"

+,13,75," I ERR=17,$E(RTN)'=""%"",$E(LAB)=""%"" Q  ;Don't flag %RTN w/o %."

+,14,0," ;Global is Error Line,tab,error tag,tab,error text"

+,15,75," S %=$G(^UTILITY($J,1,RTN,""E"",0))+1,^(0)=%,^(%)=TXT_$C(9)_ERTX"

+,16,75," Q"

+,17,0," ;"

+,18,0," ;F = Fatal, S = Standard, W = Warning, I = Info"

+,19,0,"ERROR ;"

+,20,0,"1 ;;;F - UNDEFINED COMMAND (rest of line not checked)."

+,21,0,"2 ;;;F - Non-standard (Undefined) 'Z' command."

+,22,0,"3 ;;XTRMON;F - Undefined Function."

+,23,0,"4 ;;;F - Undefined Special Variable."

+,24,0,"5 ;;;F - Unmatched Parenthesis."

+,25,0,"6 ;;;F - Unmatched Quotation Marks."

+,26,0,"7 ;;;F - ELSE Command followed by only one space."

+,27,0,"8 ;;;F - FOR Command did not contain '='."

+,28,0,"9 ;;;I - QUIT Command followed by only one space."

+,29,0,"10 ;;;F - Unrecognized argument in SET command."

+,30,0,"11 ;;;W - Invalid local variable name."

+,31,0,"12 ;;;W - Invalid global variable name."

+,32,0,"13 ;;;W - Blank(s) at end of line."

+,33,0,"14 ;;;F - Call to missing label '|' in this routine."

+,34,0,"15 ;;;W - Duplicate label. (M57)"

+,35,0,"16 ;;;F - Error in pattern code."

+,36,0,"17 ;;;W - First line label NOT routine name."

+,37,0,"18 ;;;W - Line contains a CONTROL (non-graphic) character."

+,38,0,"19 ;;;S - Line is longer than 245 bytes."

+,39,0,"20 ;;;S - View command used."

+,40,0,"21 ;;;F - General Syntax Error."

+,41,0,"22 ;;;S - Exclusive Kill."

+,42,0,"23 ;;;S - Unargumented Kill."

+,43,0,"24 ;;;S - Kill of an unsubscripted global."

+,44,0,"25 ;;;S - Break command used."

+,45,0,"26 ;;;S - Exclusive or Unargumented NEW command."

+,46,0,"27 ;;;S - $View function used."

+,47,0,"28 ;;ZOSV,ZIS,ZT;S - Non-standard $Z special variable used."

+,48,0,"29 ;;ZIS,ZTM;S - 'Close' command should be invoked through 'D ^%ZISC'."

+,49,0,"30 ;;;S - LABEL+OFFSET syntax."

+,50,0,"31 ;;ZOSV,ZIS,ZT;S - Non-standard $Z function used."

+,51,0,"32 ;;;S - 'HALT' command should be invoked through 'G ^XUSCLEAN'."

+,52,0,"33 ;;;S - Read command doesn't have a timeout."

+,53,0,"34 ;;ZIS;S - 'OPEN' command should be invoked through ^%ZIS."

+,54,0,"35 ;;;S - Routine exceeds SACC maximum size of 20000 (|)."

+,55,0,"36 ;;ZTM;S - Should use 'TASKMAN' instead of 'JOB' command."

+,56,0,"37 ;;;F - Label is not valid."

+,57,0,"38 ;;;F - Call to this |"

+,58,0,"39 ;;ZIS,XUS,XUP;S - Kill of a protected variable (|)."

+,59,0,"40 ;;;S - Space where a command should be."

+,60,0,"41 ;;;I - Star or pound READ used."

+,61,0,"42 ;;;W - Null line (no commands or comment)."

+,62,0,"43 ;;;F - Invalid or wrong number of arguments to a function."

+,63,0,"44 ;;;S - 2nd line of routine violates the SAC."

+,64,0,"45 ;;ZT,ZIS,XUTM,XTER;S - Set to a '%' global."

+,65,0,"46 ;;;F - Quoted string not followed by a separator."

+,66,0,"47 ;;;S - Lowercase command(s) used in line."

+,67,0,"48 ;;;F - Missing argument to a command post-conditional."

+,68,0,"49 ;;;F - Command missing an argument."

+,69,0,"50 ;;ZTM;S - Extended reference."

+,70,0,"51 ;;;F - Block structure mismatch."

+,71,0,"52 ;;;F - Reference to routine '^|'. That isn't in this UCI."

+,72,0,"53 ;;;F - Bad Number."

+,73,0,"54 ;;XG;S - Access to SSVN's restricted to Kernel."

+,74,0,"55 ;;;S - Violates VA programming standards."

+,75,0,"56 ;;;S - Patch number '|' missing from second line."

+,76,0,"57 ;;;S - Lower/Mixed case Variable name used."

+,77,0,"58 ;;;S - Routine code exceeds SACC maximum size of 15000 (|)."

+,78,0,"59 ;;;F - Bad WRITE syntax."

+,79,0,"60 ;;;S - Lock missing Timeout."

+,80,0,"61 ;;;S - Non-Incremental Lock."

+,81,0,"62 ;;;S - First line of routine violates the SAC."

+,82,0,"63 ;;;F - GO or DO mismatch from block structure (M45)."

+Totals for XINDX1,,529,

diff --git a/Tests/MumpsCoverage/Accounts_ReceivableTest.mcov b/Tests/MumpsCoverage/Accounts_ReceivableTest.mcov
new file mode 100644
index 0000000..3c585f5
--- /dev/null
+++ b/Tests/MumpsCoverage/Accounts_ReceivableTest.mcov
@@ -0,0 +1,1445 @@
+%GO Global Output Utility
+GT.M 17-APR-2012 17:18:27 ZWR
+^ZZCOVERAGE("%RSEL","SRC")="1:0:0:0"
+^ZZCOVERAGE("%RSEL","SRC",1)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","SRC",2)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","SRC",3)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","SRC",4)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","SRC",5)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","SRC",6)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","SRC",7)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init")="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",1)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",3)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",4)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",5)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",6)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",7)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",8)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",8,"FOR_LOOP",1)=1
+^ZZCOVERAGE("%RSEL","init",9)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",10)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",11)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",12)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",13)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",14)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",15)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",16)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",17)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","init",17,"FOR_LOOP",1)=2
+^ZZCOVERAGE("%RSEL","init",18)="2:0:0:0"
+^ZZCOVERAGE("%RSEL","init",19)="2:0:0:0"
+^ZZCOVERAGE("%RSEL","init",20)="2:0:0:0"
+^ZZCOVERAGE("%RSEL","init",40)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","main")="1:32001:84004:116005"
+^ZZCOVERAGE("%RSEL","main",1)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","main",2)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","main",3)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","main",3,"FOR_LOOP",1)=468
+^ZZCOVERAGE("%RSEL","main",4)="468:0:24003:24003"
+^ZZCOVERAGE("%RSEL","main",5)="468:0:0:0"
+^ZZCOVERAGE("%RSEL","main",6)="468:32001:48001:80002"
+^ZZCOVERAGE("%RSEL","main",7)="467:0:12000:12000"
+^ZZCOVERAGE("%RSEL","main",8)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","main",9)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","main",10)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","main",11)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","main",12)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","main",13)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","main",14)="1:0:0:0"
+^ZZCOVERAGE("%RSEL","next")="1403:12001:20002:32003"
+^ZZCOVERAGE("%RSEL","next",0)="1403:0:0:0"
+^ZZCOVERAGE("%RSEL","next",1)="1403:12001:20002:32003"
+^ZZCOVERAGE("%RSEL","next",1,"FOR_LOOP",1)=1403
+^ZZCOVERAGE("%RSEL","next",2)="1403:0:0:0"
+^ZZCOVERAGE("%RSEL","save")="467:0:4001:4001"
+^ZZCOVERAGE("%RSEL","save",1)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","save",5)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","save",6)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","save",7)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","save",8)="467:0:4001:4001"
+^ZZCOVERAGE("%RSEL","save",9)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","search")="934:0:16001:16001"
+^ZZCOVERAGE("%RSEL","search",0)="934:0:4000:4000"
+^ZZCOVERAGE("%RSEL","search",1)="934:0:0:0"
+^ZZCOVERAGE("%RSEL","search",2)="934:0:4001:4001"
+^ZZCOVERAGE("%RSEL","search",2,"FOR_LOOP",1)=1868
+^ZZCOVERAGE("%RSEL","search",3)="934:0:8000:8000"
+^ZZCOVERAGE("%RSEL","search",4)="934:0:0:0"
+^ZZCOVERAGE("%RSEL","search",5)="934:0:0:0"
+^ZZCOVERAGE("%RSEL","start")="468:0:4001:4001"
+^ZZCOVERAGE("%RSEL","start",0)="468:0:0:0"
+^ZZCOVERAGE("%RSEL","start",1)="468:0:0:0"
+^ZZCOVERAGE("%RSEL","start",2)="468:0:0:0"
+^ZZCOVERAGE("%RSEL","start",2,"FOR_LOOP",1)=936
+^ZZCOVERAGE("%RSEL","start",3)="468:0:0:0"
+^ZZCOVERAGE("%RSEL","work")="467:20002:24001:44003"
+^ZZCOVERAGE("%RSEL","work",1)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",2)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",3)="467:0:4000:4000"
+^ZZCOVERAGE("%RSEL","work",4)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",6)="467:4000:12000:16000"
+^ZZCOVERAGE("%RSEL","work",6,"FOR_LOOP",1)=3421
+^ZZCOVERAGE("%RSEL","work",7)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",8)="467:4001:0:4001"
+^ZZCOVERAGE("%RSEL","work",9)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",10)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",11)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",12)="467:4000:0:4000"
+^ZZCOVERAGE("%RSEL","work",13)="467:0:4000:4000"
+^ZZCOVERAGE("%RSEL","work",14)="467:0:0:0"
+^ZZCOVERAGE("%RSEL","work",15)="467:4001:4001:8002"
+^ZZCOVERAGE("%RSEL","work",15,"FOR_LOOP",1)=934
+^ZZCOVERAGE("%RSEL","work",16)="467:0:0:0"
+^ZZCOVERAGE("%ZIS","%ZIS")="2:0:0:0"
+^ZZCOVERAGE("%ZIS","%ZIS",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","%ZIS",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","A",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","A",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","CLEAN")="3:0:0:0"
+^ZZCOVERAGE("%ZIS","CLEAN",1)="3:0:0:0"
+^ZZCOVERAGE("%ZIS","CLEAN",2)="3:0:0:0"
+^ZZCOVERAGE("%ZIS","CLEAN",3)="3:0:0:0"
+^ZZCOVERAGE("%ZIS","CLEAN",4)="3:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME")="2:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME",1)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME",3)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME",4)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME",5)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME",6)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","GETHOME",7)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","HOME")="1:0:0:0"
+^ZZCOVERAGE("%ZIS","HOME",1)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","HOME",2)="1:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",6)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",8)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",10)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",11)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",12)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",13)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","INIT",15)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","K2",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","K2",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","K2",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","K2",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","VIRTUAL")="2:0:0:0"
+^ZZCOVERAGE("%ZIS","VIRTUAL",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","VIRTUAL",4,"FOR_LOOP",1)=6
+^ZZCOVERAGE("%ZIS","VIRTUAL",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","VIRTUAL",7)="2:0:0:0"
+^ZZCOVERAGE("%ZIS","VTLKUP")="4:0:0:0"
+^ZZCOVERAGE("%ZIS","VTLKUP",0)="4:0:0:0"
+^ZZCOVERAGE("%ZIS","VTLKUP",0,"FOR_LOOP",1)=8
+^ZZCOVERAGE("%ZIS","VTLKUP",1)="4:0:0:0"
+^ZZCOVERAGE("%ZIS1","EX2",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EX2",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EXIT",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EXIT",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EXIT",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EXIT",6)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EXIT",7)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EXIT",8)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","EXIT",9)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","G",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","IOP")="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","IOP",1)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","K2")="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","K2",1)="4:0:0:0"
+^ZZCOVERAGE("%ZIS1","K2",2)="4:0:0:0"
+^ZZCOVERAGE("%ZIS1","K2",3)="4:0:0:0"
+^ZZCOVERAGE("%ZIS1","K2",4)="4:0:0:0"
+^ZZCOVERAGE("%ZIS1","KIL",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","KIL",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","KIL",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",6)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",7)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",8)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",9)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",10)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",11)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","L1",12)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","LKUP")="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","LKUP",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","LKUP",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","LKUP",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","MAIN",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","R")="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","R",0)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","R",1)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","R",2)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","RD",0)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","RD",1)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","RD",2)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","RD",3)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","RD",4)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","RD",5)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","SBR")="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","SBR",1)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","SBR",2)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","SBR",3)="1:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETQ")="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETQ",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETQ",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETQ",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETQ",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETQ",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",7)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",8)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",9)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",10)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",11)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",12)="2:0:0:0"
+^ZZCOVERAGE("%ZIS1","SETVAR",13)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","CHECK",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","CHECK",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","CHECK",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","CHECK",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","CHECK",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","CHECK",6)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","IOPAR")="4:0:0:0"
+^ZZCOVERAGE("%ZIS2","IOPAR",0)="4:0:0:0"
+^ZZCOVERAGE("%ZIS2","IOPAR",1)="4:0:0:0"
+^ZZCOVERAGE("%ZIS2","L2")="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","L2",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OCPU",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OOS",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OOS",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU")="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU",2,"FOR_LOOP",1)=4
+^ZZCOVERAGE("%ZIS2","OTHCPU",3)="4:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU",4)="4:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU",5)="4:0:0:0"
+^ZZCOVERAGE("%ZIS2","OTHCPU",15)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","PTIME",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","QUECHK")="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","QUECHK",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","QUECHK",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","QUECHK",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","QUECHK",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","QUECHK",9)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","QUECHK",13)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","SLAVE",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","T2",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","T2",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",10)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",11)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",12)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",15)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",16)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","TMPVAR",18)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","VTRM",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS2","VTRM",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","%ZIS3",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","%ZIS3",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","%ZIS3",6)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","%ZIS3",8)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","%ZIS3",9)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","%ZIS3",11)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ALTP",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ASKMAR",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ASKMAR",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","MARGN")="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","MARGN",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","MARGN",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","MARGN",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","MARGN",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","Q",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","Q",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","Q",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","SETPAR")="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","SETPAR",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","SETPAR",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ST")="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ST",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ST",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ST",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","ST",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","STP",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","STP",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","STP",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","STP",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","TRM",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","TRM",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","TRM",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","TRM",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","TRM",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","W")="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","W",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","W",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS3","W",2)="1:0:0:0"
+^ZZCOVERAGE("%ZIS3","W",3)="1:0:0:0"
+^ZZCOVERAGE("%ZIS4","O")="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","O",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","O",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","O1")="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","O1",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","O1",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","O1",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","O1",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",4)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",5)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",9)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",10)="2:0:0:0"
+^ZZCOVERAGE("%ZIS4","OPAR",12)="2:0:0:0"
+^ZZCOVERAGE("%ZIS6","ANSBAK",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS6","ANSBAK",2)="2:0:0:0"
+^ZZCOVERAGE("%ZIS6","ANSBAK",3)="2:0:0:0"
+^ZZCOVERAGE("%ZIS6","OXECUTE",1)="2:0:0:0"
+^ZZCOVERAGE("%ZIS6","QUIT",0)="2:0:0:0"
+^ZZCOVERAGE("%ZIS6","QUIT",1)="2:0:0:0"
+^ZZCOVERAGE("%ZISC","C0")="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",1)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",3)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",5)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",6)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",8)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",9)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",10)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",13)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",16)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",17)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",21)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",26)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",27)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",29)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",32)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",33)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",34)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",37)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",41)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","C0",43)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS")="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",0)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",1)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",2)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",3)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",4)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",5)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",6)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",7)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CIOS",8)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CLOSPP")="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CLOSPP",0)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CLOSPP",1)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","CLOSPP",2)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","END",0)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","END",2)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","END",4)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","FF")="1:0:0:0"
+^ZZCOVERAGE("%ZISC","FF",0)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","FF",1)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","FF",2)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","RM")="1:0:0:0"
+^ZZCOVERAGE("%ZISC","RM",0)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","RM",1)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","S1",0)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","S1",1)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",2)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",4)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",5)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",6)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",7)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",8)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",9)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",10)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SETIO",12)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SUBTYPE")="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SUBTYPE",1)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SUBTYPE",2)="1:0:0:0"
+^ZZCOVERAGE("%ZISC","SUBTYPE",3)="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LINEPORT")="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LINEPORT",0)="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LINEPORT",2)="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LINEPORT",3)="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LINEPORT",4)="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LINEPORT",5)="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LINEPORT",6)="1:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTIEN")="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTIEN",0)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTIEN",1)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTNAM")="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTNAM",0)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTNAM",1)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTNAM",2)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTNAM",3)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTNAM",5)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTNAM",6)="3:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTSUB")="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTSUB",0)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTSUB",1)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTSUB",2)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","LNPRTSUB",3)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL")="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL",0)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL",1)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL",3)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL",4)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL",5)="2:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL",5,"FOR_LOOP",1)=40
+^ZZCOVERAGE("%ZISUTL","SYMBOL",6)="40:0:0:0"
+^ZZCOVERAGE("%ZISUTL","SYMBOL",10)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","GETENV")="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","GETENV",1)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","GETENV",2)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","GETENV",3)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","LGR")="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","LGR",0)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","LGR",1)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","PRI")="1:0:0:0"
+^ZZCOVERAGE("%ZOSV","PRI",0)="1:0:0:0"
+^ZZCOVERAGE("%ZOSV","PRI",3)="1:0:0:0"
+^ZZCOVERAGE("%ZOSV","RETURN")="2:0:4000:4000"
+^ZZCOVERAGE("%ZOSV","RETURN",0)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","RETURN",2)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","RETURN",3)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","RETURN",4)="2:0:4000:4000"
+^ZZCOVERAGE("%ZOSV","RETURN",5)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","RETURN",7)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","TEMP")="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","TEMP",0)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV","TEMP",2)="2:0:0:0"
+^ZZCOVERAGE("%ZOSV2","LOAD")="467:1000060:340019:1340079"
+^ZZCOVERAGE("%ZOSV2","LOAD",0)="467:0:0:0"
+^ZZCOVERAGE("%ZOSV2","LOAD",1)="467:0:8001:8001"
+^ZZCOVERAGE("%ZOSV2","LOAD",2)="467:1000060:320018:1320078"
+^ZZCOVERAGE("%ZOSV2","LOAD",2,"FOR_LOOP",1)=45087
+^ZZCOVERAGE("%ZOSV2","LOAD",3)="467:0:12000:12000"
+^ZZCOVERAGE("DIALOG","EZBLD")="2:0:4000:4000"
+^ZZCOVERAGE("DIALOG","EZBLD",0)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",2)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",3)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",4)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",5)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",6)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",7)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",8)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","EZBLD",9)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","PARAM")="2:0:0:0"
+^ZZCOVERAGE("DIALOG","PARAM",0)="4:0:0:0"
+^ZZCOVERAGE("DIALOG","PARAM",1)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","PARAM",2)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","PARAM",3)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","Q1",0)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","Q2")="2:0:0:0"
+^ZZCOVERAGE("DIALOG","Q2",0)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","QEZ",0)="2:0:4000:4000"
+^ZZCOVERAGE("DIALOG","QEZ",1)="2:0:0:0"
+^ZZCOVERAGE("DIALOG","QP",0)="2:0:0:0"
+^ZZCOVERAGE("DIC","A1",0)="2:0:0:0"
+^ZZCOVERAGE("DIC","ASK",0)="2:0:0:0"
+^ZZCOVERAGE("DIC","ASK",1)="2:0:0:0"
+^ZZCOVERAGE("DIC","ASK",2)="2:0:0:0"
+^ZZCOVERAGE("DIC","ASK",3)="2:0:0:0"
+^ZZCOVERAGE("DIC","ASK",4)="2:0:0:0"
+^ZZCOVERAGE("DIC","DIC")="2:0:0:0"
+^ZZCOVERAGE("DIC","DIC",3)="2:0:0:0"
+^ZZCOVERAGE("DIC","DIC",4)="2:0:0:0"
+^ZZCOVERAGE("DIC","DIC",5)="2:0:0:0"
+^ZZCOVERAGE("DIC","DIC",6)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",0)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",1)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",2)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",3)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",4)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",5)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",6)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",7)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",8)="2:0:0:0"
+^ZZCOVERAGE("DIC","EN",9)="2:0:0:0"
+^ZZCOVERAGE("DIC","RTN",0)="2:0:0:0"
+^ZZCOVERAGE("DIC","RTN",3)="2:0:0:0"
+^ZZCOVERAGE("DIC","RTN",6)="2:0:0:0"
+^ZZCOVERAGE("DIC","X",1)="2:0:0:0"
+^ZZCOVERAGE("DIC","X",4)="2:0:0:0"
+^ZZCOVERAGE("DIC","X",5)="2:0:0:0"
+^ZZCOVERAGE("DIC","X",6)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE")="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",0)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",1)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",2)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",3)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",4)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",7)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",8)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",11)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",12)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",13)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",14)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",15)="2:0:0:0"
+^ZZCOVERAGE("DIC0","GETFILE",16)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT")="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",1)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",2)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",3)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",4)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",5)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",6)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",7)="2:0:0:0"
+^ZZCOVERAGE("DIC0","INIT",8)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN")="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",0)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",1)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",2)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",3)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",4)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",5)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",5,"FOR_LOOP",1)=2
+^ZZCOVERAGE("DIC0","SETIEN",6)="2:0:0:0"
+^ZZCOVERAGE("DIC0","SETIEN",7)="2:0:0:0"
+^ZZCOVERAGE("DIC1","B",0)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DIC1")="2:0:0:0"
+^ZZCOVERAGE("DIC1","DIC1",3)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DIC1",4)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DIC1",5)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DO")="4:0:0:0"
+^ZZCOVERAGE("DIC1","DO",1)="4:0:0:0"
+^ZZCOVERAGE("DIC1","DO",2)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DO2",0)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DO2",1)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DO2",2)="2:0:0:0"
+^ZZCOVERAGE("DIC1","DO2",3)="2:0:0:0"
+^ZZCOVERAGE("DIC1","GETFA")="4:0:0:0"
+^ZZCOVERAGE("DIC1","GETFA",0)="4:0:0:0"
+^ZZCOVERAGE("DIC1","GETFA",2)="4:0:0:0"
+^ZZCOVERAGE("DIC1","P",1)="2:0:0:0"
+^ZZCOVERAGE("DIC1","P",2)="2:0:0:0"
+^ZZCOVERAGE("DIC1","PROMPT",1)="2:0:0:0"
+^ZZCOVERAGE("DIC1","PROMPT",2)="2:0:0:0"
+^ZZCOVERAGE("DIC1","W",0)="2:0:0:0"
+^ZZCOVERAGE("DIC1","W",0,"FOR_LOOP",1)=4
+^ZZCOVERAGE("DIC1","W",1)="3:0:0:0"
+^ZZCOVERAGE("DIC1","W",2)="3:0:0:0"
+^ZZCOVERAGE("DIC1","W",3)="2:0:0:0"
+^ZZCOVERAGE("DIC1","W",4)="2:0:0:0"
+^ZZCOVERAGE("DIC1","W",5)="2:0:0:0"
+^ZZCOVERAGE("DIC1","W",6)="2:0:0:0"
+^ZZCOVERAGE("DIC1","WOV")="1:0:0:0"
+^ZZCOVERAGE("DIC1","WOV",0)="1:0:0:0"
+^ZZCOVERAGE("DIC1","WOV",1)="1:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT")="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",0)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",1)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",2)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",3)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",3,"FOR_LOOP",1)=2
+^ZZCOVERAGE("DIC11","GETPRMT",4)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",8)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",9)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",10)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",11)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",12)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",13)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",14)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",15)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",16)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",17)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",18)="2:0:0:0"
+^ZZCOVERAGE("DIC11","GETPRMT",19)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",0)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",1)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",2)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",3)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",4)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",6)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",8)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",9)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",11)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",12)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",13)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",14)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",15)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PR1",16)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PROMPT")="2:0:0:0"
+^ZZCOVERAGE("DIC11","PROMPT",0)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PROMPT",1)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PROMPT",1,"FOR_LOOP",1)=2
+^ZZCOVERAGE("DIC11","PROMPT",2)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PROMPT",3)="2:0:0:0"
+^ZZCOVERAGE("DIC11","PROMPT",5)="2:0:0:0"
+^ZZCOVERAGE("DIC2","PGM")="4:0:0:0"
+^ZZCOVERAGE("DIC2","PGM",0)="4:0:0:0"
+^ZZCOVERAGE("DIC2","PGM",1)="4:0:0:0"
+^ZZCOVERAGE("DIC2","PGM",2)="4:0:0:0"
+^ZZCOVERAGE("DIC2","Q")="2:0:0:0"
+^ZZCOVERAGE("DIC2","Q",0)="2:0:0:0"
+^ZZCOVERAGE("DIC2","Q",1)="2:0:0:0"
+^ZZCOVERAGE("DIC2","Q",2)="2:0:0:0"
+^ZZCOVERAGE("DICL","DINDEX")="2:0:0:0"
+^ZZCOVERAGE("DICL","DINDEX",0)="2:0:0:0"
+^ZZCOVERAGE("DICL","DINDEX",1)="2:0:0:0"
+^ZZCOVERAGE("DICL","DINDEX",2)="2:0:0:0"
+^ZZCOVERAGE("DICL","DINDEX",5)="2:0:0:0"
+^ZZCOVERAGE("DICL","DINDEX",6)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","I1",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","I1",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","I1",4)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","I1",5)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","INDEX")="2:0:0:0"
+^ZZCOVERAGE("DICUIX","INDEX",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X1",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X1",8)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X1",9)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",4)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",5)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",8)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",11)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",12)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",13)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",14)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",15)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",15,"FOR_LOOP",1)=2
+^ZZCOVERAGE("DICUIX","X2",16)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",17)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",18)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",19)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",20)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",21)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",22)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",23)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",24)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",25)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",26)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",27)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",28)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",29)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",30)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",31)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",32)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","X2",33)="2:0:0:0"
+^ZZCOVERAGE("DICUIX","XREF")="2:0:0:0"
+^ZZCOVERAGE("DICUIX","XREF",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G1",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G1",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G1",4)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G2",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G2",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G3",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G30",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G4",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G4",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G4",4)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G4",5)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G4",6)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G4",7)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G5",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G5",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","G5",7)="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","GET")="2:0:0:0"
+^ZZCOVERAGE("DICUIX1","GET",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C1",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C1",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C2",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C2",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C3",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C3",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C3",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C3",5)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",4)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",5)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",6)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",7)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",8)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",9)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",10)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",11)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",12)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",17)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",18)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",23)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C4",24)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C5",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C5",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C6",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C6",18)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C6",19)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C6",20)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C7",0)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","C7",7)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1")="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1",4)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1",5)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1",6)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON1",7)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2")="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",1)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",2)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",3)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",4)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",5)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",6)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",7)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",8)="2:0:0:0"
+^ZZCOVERAGE("DICUIX2","COMMON2",9)="2:0:0:0"
+^ZZCOVERAGE("DIEFU","IENX",1)="2:0:0:0"
+^ZZCOVERAGE("DIEFU","IENX",2)="2:0:0:0"
+^ZZCOVERAGE("DIEFU","IENX",3)="2:0:0:0"
+^ZZCOVERAGE("DIEFU","IENX",3,"FOR_LOOP",1)=4
+^ZZCOVERAGE("DIEFU","IENX",4)="2:0:0:0"
+^ZZCOVERAGE("DIEFU","IENX",5)="2:0:0:0"
+^ZZCOVERAGE("DILF","CREF")="4:0:0:0"
+^ZZCOVERAGE("DILF","CREF",0)="4:0:0:0"
+^ZZCOVERAGE("DILF","IENS")="2:0:0:0"
+^ZZCOVERAGE("DILF","IENS",0)="2:0:0:0"
+^ZZCOVERAGE("DILF","IENS",1)="2:0:0:0"
+^ZZCOVERAGE("DILF","OREF")="2:0:0:0"
+^ZZCOVERAGE("DILF","OREF",0)="2:0:0:0"
+^ZZCOVERAGE("DILIBF","FNO")="2:0:0:0"
+^ZZCOVERAGE("DILIBF","FNO",0)="2:0:0:0"
+^ZZCOVERAGE("DILIBF","FNO",1)="2:0:0:0"
+^ZZCOVERAGE("DILIBF","FNO",2)="2:0:0:0"
+^ZZCOVERAGE("DIQGU","ENCREF",0)="4:0:0:0"
+^ZZCOVERAGE("DIQGU","ENOREF",0)="2:0:0:0"
+^ZZCOVERAGE("DIQGU","OR2")="2:0:0:0"
+^ZZCOVERAGE("DIQGU","OR2",0)="2:0:0:0"
+^ZZCOVERAGE("XINDEX","A2",0)="468:0:4000:4000"
+^ZZCOVERAGE("XINDEX","A2",1)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","A2",2)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","A2",3)="467:4000:0:4000"
+^ZZCOVERAGE("XINDEX","A2",4)="467:0:4000:4000"
+^ZZCOVERAGE("XINDEX","A2",5)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","ALIVE",1)="1:0:0:0"
+^ZZCOVERAGE("XINDEX","B5",0)="467:188012:220012:408024"
+^ZZCOVERAGE("XINDEX","B5",0,"FOR_LOOP",1)=44620
+^ZZCOVERAGE("XINDEX","B5",1)="467:20000:8000:28000"
+^ZZCOVERAGE("XINDEX","B5",2)="467:4000:0:4000"
+^ZZCOVERAGE("XINDEX","B5",3)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","B5",4)="467:4000:0:4000"
+^ZZCOVERAGE("XINDEX","B5",5)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","BEG")="467:2460149:2872194:5332343"
+^ZZCOVERAGE("XINDEX","BEG",1)="467:8000:0:8000"
+^ZZCOVERAGE("XINDEX","BEG",2)="467:4000:0:4000"
+^ZZCOVERAGE("XINDEX","BEG",3)="467:0:4000:4000"
+^ZZCOVERAGE("XINDEX","BEG",4)="467:0:4000:4000"
+^ZZCOVERAGE("XINDEX","BEG",5)="467:4001:0:4001"
+^ZZCOVERAGE("XINDEX","BEG",7)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","BEG",8)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","BEG",9)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","BEG",11)="467:4000:0:4000"
+^ZZCOVERAGE("XINDEX","BEG",12)="467:0:4000:4000"
+^ZZCOVERAGE("XINDEX","BEG",14)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","BEG",15)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","BEG",16)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","CD",0)="44620:32001:36002:68003"
+^ZZCOVERAGE("XINDEX","CD",1)="44620:40002:60004:100006"
+^ZZCOVERAGE("XINDEX","CD",2)="44620:40001:60002:100003"
+^ZZCOVERAGE("XINDEX","CD",3)="44620:36002:44004:80006"
+^ZZCOVERAGE("XINDEX","CD",4)="44620:28000:40002:68002"
+^ZZCOVERAGE("XINDEX","CD",5)="44620:28002:52001:80003"
+^ZZCOVERAGE("XINDEX","CD",6)="10770:28003:20000:48003"
+^ZZCOVERAGE("XINDEX","CD",6,"FOR_LOOP",1)=57531
+^ZZCOVERAGE("XINDEX","CD",7)="10770:24004:16000:40004"
+^ZZCOVERAGE("XINDEX","CD",9)="44620:60005:40004:100009"
+^ZZCOVERAGE("XINDEX","CD",10)="44620:44003:48005:92008"
+^ZZCOVERAGE("XINDEX","CD",12)="44620:52004:44002:96006"
+^ZZCOVERAGE("XINDEX","EE",0)="116081:148007:200014:348021"
+^ZZCOVERAGE("XINDEX","EE",1)="71461:44004:44002:88006"
+^ZZCOVERAGE("XINDEX","EE",2)="71461:100007:80003:180010"
+^ZZCOVERAGE("XINDEX","EE",3)="54870:44001:48001:92002"
+^ZZCOVERAGE("XINDEX","EE",4)="53608:88008:100009:188017"
+^ZZCOVERAGE("XINDEX","EE",5)="53608:72006:68004:140010"
+^ZZCOVERAGE("XINDEX","EE",6)="53608:76005:72004:148009"
+^ZZCOVERAGE("XINDEX","EE",8)="53608:60003:64005:124008"
+^ZZCOVERAGE("XINDEX","EE",9)="53608:48003:72003:120006"
+^ZZCOVERAGE("XINDEX","EE",10)="53608:52002:96008:148010"
+^ZZCOVERAGE("XINDEX","EE",13)="53608:52003:44001:96004"
+^ZZCOVERAGE("XINDEX","EE",14)="53608:96007:112006:208013"
+^ZZCOVERAGE("XINDEX","EE",15)="53608:24001:52004:76005"
+^ZZCOVERAGE("XINDEX","EE",16)="53608:52005:88007:140012"
+^ZZCOVERAGE("XINDEX","EE",17)="53608:128008:208017:336025"
+^ZZCOVERAGE("XINDEX","F")="1559:4000:4001:8001"
+^ZZCOVERAGE("XINDEX","F",0)="1559:4000:0:4000"
+^ZZCOVERAGE("XINDEX","G")="1932:56003:96009:152012"
+^ZZCOVERAGE("XINDEX","G",0)="1932:4000:8002:12002"
+^ZZCOVERAGE("XINDEX","H")="11:0:0:0"
+^ZZCOVERAGE("XINDEX","H",0)="11:0:0:0"
+^ZZCOVERAGE("XINDEX","K")="2218:40001:24002:64003"
+^ZZCOVERAGE("XINDEX","K",0)="2218:4000:4000:8000"
+^ZZCOVERAGE("XINDEX","K",1)="2218:0:4001:4001"
+^ZZCOVERAGE("XINDEX","L")="259:4001:4000:8001"
+^ZZCOVERAGE("XINDEX","L",0)="259:0:0:0"
+^ZZCOVERAGE("XINDEX","LN",0)="44620:68005:104005:172010"
+^ZZCOVERAGE("XINDEX","LN",1)="44620:40001:64004:104005"
+^ZZCOVERAGE("XINDEX","LN",2)="5073:12000:4001:16001"
+^ZZCOVERAGE("XINDEX","LN",3)="5073:4000:8000:12000"
+^ZZCOVERAGE("XINDEX","LN",4)="5073:20001:0:20001"
+^ZZCOVERAGE("XINDEX","LN",5)="5073:20003:12002:32005"
+^ZZCOVERAGE("XINDEX","LN",6)="5073:12002:16000:28002"
+^ZZCOVERAGE("XINDEX","LOAD")="467:88003:196019:284022"
+^ZZCOVERAGE("XINDEX","LOAD",0)="467:88003:196019:284022"
+^ZZCOVERAGE("XINDEX","LOAD",1)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","LOAD",2)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","M")="30:4000:0:4000"
+^ZZCOVERAGE("XINDEX","M",0)="30:0:0:0"
+^ZZCOVERAGE("XINDEX","N")="1721:88005:80004:168009"
+^ZZCOVERAGE("XINDEX","N",0)="1721:4000:0:4000"
+^ZZCOVERAGE("XINDEX","POSTRTN")="467:108009:96003:204012"
+^ZZCOVERAGE("XINDEX","POSTRTN",1)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","POSTRTN",2)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","POSTRTN",3)="467:12000:8000:20000"
+^ZZCOVERAGE("XINDEX","POSTRTN",3,"FOR_LOOP",1)=2558
+^ZZCOVERAGE("XINDEX","POSTRTN",4)="2091:0:0:0"
+^ZZCOVERAGE("XINDEX","POSTRTN",5)="2044:4000:0:4000"
+^ZZCOVERAGE("XINDEX","POSTRTN",6)="2044:4000:0:4000"
+^ZZCOVERAGE("XINDEX","POSTRTN",9)="2044:0:0:0"
+^ZZCOVERAGE("XINDEX","POSTRTN",10)="467:0:4000:4000"
+^ZZCOVERAGE("XINDEX","POSTRTN",11)="467:12002:16001:28003"
+^ZZCOVERAGE("XINDEX","POSTRTN",11,"FOR_LOOP",1)=5540
+^ZZCOVERAGE("XINDEX","POSTRTN",12)="5073:0:4000:4000"
+^ZZCOVERAGE("XINDEX","POSTRTN",13)="5073:8000:4000:12000"
+^ZZCOVERAGE("XINDEX","POSTRTN",14)="5073:0:0:0"
+^ZZCOVERAGE("XINDEX","POSTRTN",15)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","POSTRTN",16)="467:28001:20001:48002"
+^ZZCOVERAGE("XINDEX","POSTRTN",16,"FOR_LOOP",1)=16376
+^ZZCOVERAGE("XINDEX","POSTRTN",17)="15909:40006:40001:80007"
+^ZZCOVERAGE("XINDEX","POSTRTN",18)="15909:0:0:0"
+^ZZCOVERAGE("XINDEX","POSTRTN",19)="467:0:0:0"
+^ZZCOVERAGE("XINDEX","Q")="7762:12000:20001:32001"
+^ZZCOVERAGE("XINDEX","Q",0)="7762:4000:16001:20001"
+^ZZCOVERAGE("XINDEX","QUOTE")="36371:188012:232009:420021"
+^ZZCOVERAGE("XINDEX","QUOTE",0)="36371:156010:192008:348018"
+^ZZCOVERAGE("XINDEX","QUOTE",0,"FOR_LOOP",1)=323268
+^ZZCOVERAGE("XINDEX","QUOTE",1)="36371:20002:20001:40003"
+^ZZCOVERAGE("XINDEX","R")="85:0:8001:8001"
+^ZZCOVERAGE("XINDEX","R",0)="85:0:0:0"
+^ZZCOVERAGE("XINDEX","S")="17549:716055:988057:1704112"
+^ZZCOVERAGE("XINDEX","S",0)="17549:28003:28003:56006"
+^ZZCOVERAGE("XINDEX","SE2",0)="86891:176010:272017:448027"
+^ZZCOVERAGE("XINDEX","SE2",1)="85079:264015:376016:640031"
+^ZZCOVERAGE("XINDEX","SE2",2)="85079:72005:112010:184015"
+^ZZCOVERAGE("XINDEX","SEP")="107216:736054:648038:1384092"
+^ZZCOVERAGE("XINDEX","SEP",0)="107216:580045:440030:1020075"
+^ZZCOVERAGE("XINDEX","SEP",0,"FOR_LOOP",1)=1019212
+^ZZCOVERAGE("XINDEX","SEP",1)="107216:120007:144005:264012"
+^ZZCOVERAGE("XINDEX","SET")="85079:772044:1124063:1896107"
+^ZZCOVERAGE("XINDEX","SET",0)="85079:176007:168008:344015"
+^ZZCOVERAGE("XINDEX","SET",0,"FOR_LOOP",1)=74812
+^ZZCOVERAGE("XINDEX","SET",1)="85079:64005:144010:208015"
+^ZZCOVERAGE("XINDEX","ST",0)="44620:68001:56004:124005"
+^ZZCOVERAGE("XINDEX","ST",2)="44620:260012:376038:636050"
+^ZZCOVERAGE("XINDEX","ST",2,"FOR_LOOP",1)=85813
+^ZZCOVERAGE("XINDEX","ST",2,"FOR_LOOP",2)=126272
+^ZZCOVERAGE("XINDEX","ST",3)="44620:224014:184014:408028"
+^ZZCOVERAGE("XINDEX","ST",4)="44620:0:0:0"
+^ZZCOVERAGE("XINDEX","U")="72:0:0:0"
+^ZZCOVERAGE("XINDEX","U",0)="72:0:0:0"
+^ZZCOVERAGE("XINDEX","W")="4584:156009:200014:356023"
+^ZZCOVERAGE("XINDEX","W",0)="4584:0:16001:16001"
+^ZZCOVERAGE("XINDEX","X")="220:0:0:0"
+^ZZCOVERAGE("XINDEX","X",0)="220:0:0:0"
+^ZZCOVERAGE("XINDEX","XINDEX")="1:32002:36000:68002"
+^ZZCOVERAGE("XINDEX","XINDEX",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX1","A",0)="75:0:4000:4000"
+^ZZCOVERAGE("XINDX1","A",1)="75:0:0:0"
+^ZZCOVERAGE("XINDX1","A",2)="75:0:0:0"
+^ZZCOVERAGE("XINDX1","B",0)="75:0:0:0"
+^ZZCOVERAGE("XINDX1","B",4)="75:0:0:0"
+^ZZCOVERAGE("XINDX1","B",6)="75:0:0:0"
+^ZZCOVERAGE("XINDX1","B",7)="75:0:0:0"
+^ZZCOVERAGE("XINDX1","E")="73:0:4000:4000"
+^ZZCOVERAGE("XINDX1","E",0)="73:0:0:0"
+^ZZCOVERAGE("XINDX1","XINDX1")="2:0:0:0"
+^ZZCOVERAGE("XINDX1","XINDX1",3)="2:0:0:0"
+^ZZCOVERAGE("XINDX10","ASK")="1:0:0:0"
+^ZZCOVERAGE("XINDX10","ASK",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX10","ASK",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX10","ASK",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX10","ASK",8)="1:0:0:0"
+^ZZCOVERAGE("XINDX2","%")="44620:132010:232014:364024"
+^ZZCOVERAGE("XINDX2","%",0)="44620:96008:92005:188013"
+^ZZCOVERAGE("XINDX2","%",0,"FOR_LOOP",1)=62810
+^ZZCOVERAGE("XINDX2","%",1)="44620:16001:68003:84004"
+^ZZCOVERAGE("XINDX2","ARG")="329774:1516089:2124136:3640225"
+^ZZCOVERAGE("XINDX2","ARG",1)="330498:328020:360021:688041"
+^ZZCOVERAGE("XINDX2","ARG",2)="262221:228015:296022:524037"
+^ZZCOVERAGE("XINDX2","ARG",3)="226556:260020:468034:728054"
+^ZZCOVERAGE("XINDX2","ARG",4)="126854:104004:160011:264015"
+^ZZCOVERAGE("XINDX2","ARG",5)="117750:136007:148011:284018"
+^ZZCOVERAGE("XINDX2","ARG",6)="88629:60001:96003:156004"
+^ZZCOVERAGE("XINDX2","ARG",7)="88424:80005:100006:180011"
+^ZZCOVERAGE("XINDX2","ARG",8)="86550:72002:108007:180009"
+^ZZCOVERAGE("XINDX2","ARGG")="18715:288018:352019:640037"
+^ZZCOVERAGE("XINDX2","ARGG",0)="18715:76007:84005:160012"
+^ZZCOVERAGE("XINDX2","ARGG",0,"FOR_LOOP",1)=49672
+^ZZCOVERAGE("XINDX2","ARGS")="44410:464031:676031:1140062"
+^ZZCOVERAGE("XINDX2","ARGS",1)="63125:620038:844037:1464075"
+^ZZCOVERAGE("XINDX2","ARGS",1,"FOR_LOOP",1)=291597
+^ZZCOVERAGE("XINDX2","ARGS",2)="63125:24001:60004:84005"
+^ZZCOVERAGE("XINDX2","DN")="44410:208011:284017:492028"
+^ZZCOVERAGE("XINDX2","DN",0)="44410:44003:108008:152011"
+^ZZCOVERAGE("XINDX2","DN",1)="44410:152008:144006:296014"
+^ZZCOVERAGE("XINDX2","EXT",1)="1970:4000:8001:12001"
+^ZZCOVERAGE("XINDX2","EXT",2)="1970:0:0:0"
+^ZZCOVERAGE("XINDX2","EXT",3)="1970:8001:12001:20002"
+^ZZCOVERAGE("XINDX2","EXT",4)="1970:0:4000:4000"
+^ZZCOVERAGE("XINDX2","FLUSH")="94:0:0:0"
+^ZZCOVERAGE("XINDX2","FLUSH",0)="94:0:0:0"
+^ZZCOVERAGE("XINDX2","FLUSH",1)="94:0:0:0"
+^ZZCOVERAGE("XINDX2","FLUSH",1,"FOR_LOOP",1)=415
+^ZZCOVERAGE("XINDX2","FLUSH",2)="94:0:0:0"
+^ZZCOVERAGE("XINDX2","FNC")="12:0:0:0"
+^ZZCOVERAGE("XINDX2","FNC",0)="12:0:0:0"
+^ZZCOVERAGE("XINDX2","FNC",1)="12:0:0:0"
+^ZZCOVERAGE("XINDX2","FNC",2)="12:0:0:0"
+^ZZCOVERAGE("XINDX2","FNC",3)="12:0:0:0"
+^ZZCOVERAGE("XINDX2","FNC",4)="12:0:0:0"
+^ZZCOVERAGE("XINDX2","FUN")="29121:340019:424027:764046"
+^ZZCOVERAGE("XINDX2","FUN",0)="29121:36004:40002:76006"
+^ZZCOVERAGE("XINDX2","FUN",1)="23452:48002:72003:120005"
+^ZZCOVERAGE("XINDX2","FUN",2)="23452:20000:44003:64003"
+^ZZCOVERAGE("XINDX2","FUN",3)="23393:96004:56005:152009"
+^ZZCOVERAGE("XINDX2","FUN",3,"FOR_LOOP",1)=147754
+^ZZCOVERAGE("XINDX2","FUN",4)="23393:48003:56005:104008"
+^ZZCOVERAGE("XINDX2","FUN",5)="23393:60004:92005:152009"
+^ZZCOVERAGE("XINDX2","GLO",0)="9104:28002:28001:56003"
+^ZZCOVERAGE("XINDX2","GLO",1)="9104:12001:20001:32002"
+^ZZCOVERAGE("XINDX2","GLO",2)="9104:16000:28001:44001"
+^ZZCOVERAGE("XINDX2","GLO",3)="9104:36002:80004:116006"
+^ZZCOVERAGE("XINDX2","GLO",4)="9104:8000:4000:12000"
+^ZZCOVERAGE("XINDX2","INC")="322910:416022:652029:1068051"
+^ZZCOVERAGE("XINDX2","INC",0)="365505:320019:472020:792039"
+^ZZCOVERAGE("XINDX2","INC2")="42595:104006:148008:252014"
+^ZZCOVERAGE("XINDX2","INC2",0)="42595:48001:40003:88004"
+^ZZCOVERAGE("XINDX2","LOC")="99702:576031:736052:1312083"
+^ZZCOVERAGE("XINDX2","LOC",0)="99702:144010:156013:300023"
+^ZZCOVERAGE("XINDX2","LOC",1)="99702:124004:148011:272015"
+^ZZCOVERAGE("XINDX2","LOC",2)="99702:212011:272014:484025"
+^ZZCOVERAGE("XINDX2","LOC",3)="99702:52005:96006:148011"
+^ZZCOVERAGE("XINDX2","NAK",0)="996:0:0:0"
+^ZZCOVERAGE("XINDX2","NAK",1)="996:0:0:0"
+^ZZCOVERAGE("XINDX2","PAT")="205:4000:0:4000"
+^ZZCOVERAGE("XINDX2","PAT",0)="205:0:0:0"
+^ZZCOVERAGE("XINDX2","PAT",1)="205:4000:0:4000"
+^ZZCOVERAGE("XINDX2","PAT",1,"FOR_LOOP",1)=457
+^ZZCOVERAGE("XINDX2","PAT",2)="205:0:0:0"
+^ZZCOVERAGE("XINDX2","PATCODE")="457:4000:4000:8000"
+^ZZCOVERAGE("XINDX2","PATCODE",0)="457:0:4000:4000"
+^ZZCOVERAGE("XINDX2","PATCODE",1)="358:4000:0:4000"
+^ZZCOVERAGE("XINDX2","PATCODE",1,"FOR_LOOP",1)=791
+^ZZCOVERAGE("XINDX2","PATCODE",2)="358:0:0:0"
+^ZZCOVERAGE("XINDX2","PATCODE",3)="358:0:0:0"
+^ZZCOVERAGE("XINDX2","PATCODE",4)="358:0:0:0"
+^ZZCOVERAGE("XINDX2","PATQ")="99:4000:4000:8000"
+^ZZCOVERAGE("XINDX2","PATQ",0)="99:0:4000:4000"
+^ZZCOVERAGE("XINDX2","PATQ",0,"FOR_LOOP",1)=247
+^ZZCOVERAGE("XINDX2","PATQ",1)="99:4000:0:4000"
+^ZZCOVERAGE("XINDX2","PATQ",2)="99:0:0:0"
+^ZZCOVERAGE("XINDX2","PEEK")="112687:168013:248022:416035"
+^ZZCOVERAGE("XINDX2","PEEK",0)="112687:120009:164010:284019"
+^ZZCOVERAGE("XINDX2","PEEKDN")="17373:56002:40000:96002"
+^ZZCOVERAGE("XINDX2","PEEKDN",0)="17373:48002:32000:80002"
+^ZZCOVERAGE("XINDX2","REPCNT")="457:0:0:0"
+^ZZCOVERAGE("XINDX2","REPCNT",0)="457:0:0:0"
+^ZZCOVERAGE("XINDX2","REPCNT",0,"FOR_LOOP",1)=1004
+^ZZCOVERAGE("XINDX2","REPCNT",1)="457:0:0:0"
+^ZZCOVERAGE("XINDX2","REPCNT",2)="457:0:0:0"
+^ZZCOVERAGE("XINDX2","SPV",1)="3699:0:8001:8001"
+^ZZCOVERAGE("XINDX2","SPV",2)="3699:0:0:0"
+^ZZCOVERAGE("XINDX2","ST")="110835:464030:648049:1112079"
+^ZZCOVERAGE("XINDX2","ST",0)="110835:192009:248021:440030"
+^ZZCOVERAGE("XINDX2","ST",1)="110835:100008:156011:256019"
+^ZZCOVERAGE("XINDX2","ST",2)="110835:76005:116005:192010"
+^ZZCOVERAGE("XINDX2","TEXT",0)="59:0:0:0"
+^ZZCOVERAGE("XINDX2","TEXT",1)="59:0:0:0"
+^ZZCOVERAGE("XINDX2","TEXT",2)="59:0:0:0"
+^ZZCOVERAGE("XINDX2","TEXT",3)="59:0:0:0"
+^ZZCOVERAGE("XINDX2","UP")="44410:116012:180012:296024"
+^ZZCOVERAGE("XINDX2","UP",1)="44410:112012:116006:228018"
+^ZZCOVERAGE("XINDX2","VA")="5073:16001:20000:36001"
+^ZZCOVERAGE("XINDX2","VA",0)="5073:4000:12000:16000"
+^ZZCOVERAGE("XINDX2","VA",1)="5073:8000:4000:12000"
+^ZZCOVERAGE("XINDX2","VT")="10205:4001:24002:28003"
+^ZZCOVERAGE("XINDX2","VT",0)="10205:0:8000:8000"
+^ZZCOVERAGE("XINDX2","VT",1)="10205:0:4000:4000"
+^ZZCOVERAGE("XINDX3","A",0)="8136:36001:12001:48002"
+^ZZCOVERAGE("XINDX3","ASM")="312:12001:0:12001"
+^ZZCOVERAGE("XINDX3","ASM",0)="312:0:0:0"
+^ZZCOVERAGE("XINDX3","ASM",1)="312:8001:0:8001"
+^ZZCOVERAGE("XINDX3","ASM",1,"FOR_LOOP",1)=2110
+^ZZCOVERAGE("XINDX3","ASM",2)="312:0:0:0"
+^ZZCOVERAGE("XINDX3","DN")="498:4000:4000:8000"
+^ZZCOVERAGE("XINDX3","DN",0)="498:0:4000:4000"
+^ZZCOVERAGE("XINDX3","DN",1)="498:4000:0:4000"
+^ZZCOVERAGE("XINDX3","FL")="63250:152007:260014:412021"
+^ZZCOVERAGE("XINDX3","FL",1)="63250:72000:144009:216009"
+^ZZCOVERAGE("XINDX3","FL",2)="63250:64006:80004:144010"
+^ZZCOVERAGE("XINDX3","INC")="145482:224018:308026:532044"
+^ZZCOVERAGE("XINDX3","INC",0)="145482:188015:196015:384030"
+^ZZCOVERAGE("XINDX3","KL",1)="2218:0:4000:4000"
+^ZZCOVERAGE("XINDX3","KL1")="28:0:0:0"
+^ZZCOVERAGE("XINDX3","KL1",0)="28:0:0:0"
+^ZZCOVERAGE("XINDX3","KL2")="724:4000:28000:32000"
+^ZZCOVERAGE("XINDX3","KL2",0)="724:0:0:0"
+^ZZCOVERAGE("XINDX3","KL2",1)="724:0:4000:4000"
+^ZZCOVERAGE("XINDX3","KL2",2)="724:0:0:0"
+^ZZCOVERAGE("XINDX3","KL3")="3320:12002:36002:48004"
+^ZZCOVERAGE("XINDX3","KL3",0)="3320:4000:8000:12000"
+^ZZCOVERAGE("XINDX3","KL3",1)="3320:4001:4000:8001"
+^ZZCOVERAGE("XINDX3","KL5",0)="3320:0:20002:20002"
+^ZZCOVERAGE("XINDX3","MULT")="498:8001:4000:12001"
+^ZZCOVERAGE("XINDX3","MULT",0)="498:4001:0:4001"
+^ZZCOVERAGE("XINDX3","MULT",1)="498:4000:4000:8000"
+^ZZCOVERAGE("XINDX3","MULT",1,"FOR_LOOP",1)=2401
+^ZZCOVERAGE("XINDX3","MULT",2)="498:0:0:0"
+^ZZCOVERAGE("XINDX3","N2",0)="23604:68004:36003:104007"
+^ZZCOVERAGE("XINDX3","N2",3)="11802:16002:4000:20002"
+^ZZCOVERAGE("XINDX3","N2",4)="187:0:0:0"
+^ZZCOVERAGE("XINDX3","N2",5)="187:0:0:0"
+^ZZCOVERAGE("XINDX3","N2",6)="11628:12001:20002:32003"
+^ZZCOVERAGE("XINDX3","N2",7)="11628:12000:8000:20000"
+^ZZCOVERAGE("XINDX3","NE")="779:32002:16001:48003"
+^ZZCOVERAGE("XINDX3","NE",1)="2500:4000:4000:8000"
+^ZZCOVERAGE("XINDX3","NE",2)="2500:4000:20000:24000"
+^ZZCOVERAGE("XINDX3","PEEK")="498:0:0:0"
+^ZZCOVERAGE("XINDX3","PEEK",0)="498:0:0:0"
+^ZZCOVERAGE("XINDX3","PEEKDN")="39:0:0:0"
+^ZZCOVERAGE("XINDX3","PEEKDN",0)="39:0:0:0"
+^ZZCOVERAGE("XINDX3","RD",0)="85:0:0:0"
+^ZZCOVERAGE("XINDX3","RD1",0)="278:0:4001:4001"
+^ZZCOVERAGE("XINDX3","RD1",3)="193:0:4000:4000"
+^ZZCOVERAGE("XINDX3","RD1",4)="85:0:0:0"
+^ZZCOVERAGE("XINDX3","RD1",5)="85:0:0:0"
+^ZZCOVERAGE("XINDX3","RD2")="85:0:4000:4000"
+^ZZCOVERAGE("XINDX3","RD2",0)="255:0:0:0"
+^ZZCOVERAGE("XINDX3","RD2",1)="170:0:0:0"
+^ZZCOVERAGE("XINDX3","RD2",2)="170:0:4000:4000"
+^ZZCOVERAGE("XINDX3","RD2",3)="85:0:0:0"
+^ZZCOVERAGE("XINDX3","RD3")="108:0:0:0"
+^ZZCOVERAGE("XINDX3","RD3",0)="161:0:0:0"
+^ZZCOVERAGE("XINDX3","RD3",1)="37:0:0:0"
+^ZZCOVERAGE("XINDX3","RD3",2)="37:0:0:0"
+^ZZCOVERAGE("XINDX3","S",1)="17579:48005:56003:104008"
+^ZZCOVERAGE("XINDX3","S2",0)="110559:164008:220011:384019"
+^ZZCOVERAGE("XINDX3","S2",1)="92980:64007:96005:160012"
+^ZZCOVERAGE("XINDX3","S2",2)="92980:52004:100005:152009"
+^ZZCOVERAGE("XINDX3","S2",3)="87238:60005:68003:128008"
+^ZZCOVERAGE("XINDX3","S2",4)="63916:68007:68004:136011"
+^ZZCOVERAGE("XINDX3","S2",5)="846:0:0:0"
+^ZZCOVERAGE("XINDX3","S2",6)="846:0:4000:4000"
+^ZZCOVERAGE("XINDX3","S2",10)="63916:56004:60003:116007"
+^ZZCOVERAGE("XINDX3","S2",11)="62481:40002:60003:100005"
+^ZZCOVERAGE("XINDX3","S2",12)="62313:56003:56005:112008"
+^ZZCOVERAGE("XINDX3","S2",13)="61815:76007:152010:228017"
+^ZZCOVERAGE("XINDX3","UP")="498:8000:4000:12000"
+^ZZCOVERAGE("XINDX3","UP",1)="498:8000:4000:12000"
+^ZZCOVERAGE("XINDX3","VLN",1)="15909:32002:16001:48003"
+^ZZCOVERAGE("XINDX3","VLN",2)="15909:44002:28003:72005"
+^ZZCOVERAGE("XINDX3","VLNF")="15909:120006:60005:180011"
+^ZZCOVERAGE("XINDX3","VLNF",0)="15909:32002:12001:44003"
+^ZZCOVERAGE("XINDX4","CNG")="2186:0:24001:24001"
+^ZZCOVERAGE("XINDX4","CNG",0)="2186:0:0:0"
+^ZZCOVERAGE("XINDX4","CNG",2)="2186:0:8001:8001"
+^ZZCOVERAGE("XINDX4","CNG",2,"FOR_LOOP",1)=2202
+^ZZCOVERAGE("XINDX4","CNG",3)="2186:0:12000:12000"
+^ZZCOVERAGE("XINDX4","DG",0)="8937:20003:16000:36003"
+^ZZCOVERAGE("XINDX4","DG",1)="8937:12000:16001:28001"
+^ZZCOVERAGE("XINDX4","DG",2)="8937:8001:20002:28003"
+^ZZCOVERAGE("XINDX4","DG",3)="8937:16000:12000:28000"
+^ZZCOVERAGE("XINDX4","DG",4)="8937:4000:12001:16001"
+^ZZCOVERAGE("XINDX4","DG",5)="8937:0:12002:12002"
+^ZZCOVERAGE("XINDX4","DG",6)="8937:12001:12000:24001"
+^ZZCOVERAGE("XINDX4","DG",7)="8937:12000:20003:32003"
+^ZZCOVERAGE("XINDX4","DG",8)="8937:24001:4001:28002"
+^ZZCOVERAGE("XINDX4","DG",9)="8937:4000:12001:16001"
+^ZZCOVERAGE("XINDX4","DG",10)="8937:16001:28001:44002"
+^ZZCOVERAGE("XINDX4","DG",11)="8937:8000:12000:20000"
+^ZZCOVERAGE("XINDX4","DG",12)="8937:4000:16002:20002"
+^ZZCOVERAGE("XINDX4","DG",13)="8937:8000:12002:20002"
+^ZZCOVERAGE("XINDX4","DG",14)="8937:0:4000:4000"
+^ZZCOVERAGE("XINDX4","DG",15)="8937:36002:32002:68004"
+^ZZCOVERAGE("XINDX4","DG",16)="8937:8001:4001:12002"
+^ZZCOVERAGE("XINDX4","DG",17)="8387:12002:4000:16002"
+^ZZCOVERAGE("XINDX4","DG1")="8449:168011:180013:348024"
+^ZZCOVERAGE("XINDX4","DG1",0)="8449:12001:16001:28002"
+^ZZCOVERAGE("XINDX4","FR",0)="525:0:4001:4001"
+^ZZCOVERAGE("XINDX4","FR",1)="525:0:0:0"
+^ZZCOVERAGE("XINDX4","FR",2)="525:0:0:0"
+^ZZCOVERAGE("XINDX4","INSIDE")="2202:4001:32001:36002"
+^ZZCOVERAGE("XINDX4","INSIDE",0)="2202:0:16000:16000"
+^ZZCOVERAGE("XINDX4","INSIDE",1)="2202:0:4000:4000"
+^ZZCOVERAGE("XINDX4","INSIDE",2)="2202:4001:4000:8001"
+^ZZCOVERAGE("XINDX4","LO",1)="259:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",2)="259:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",3)="259:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",4)="259:0:4000:4000"
+^ZZCOVERAGE("XINDX4","LO",4,"FOR_LOOP",1)=260
+^ZZCOVERAGE("XINDX4","LO",5)="260:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",6)="260:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",7)="260:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",8)="89:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",9)="89:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",10)="89:4001:0:4001"
+^ZZCOVERAGE("XINDX4","LO",12)="259:0:0:0"
+^ZZCOVERAGE("XINDX4","LO",13)="259:0:0:0"
+^ZZCOVERAGE("XINDX4","LOOP")="14735:44003:108008:152011"
+^ZZCOVERAGE("XINDX4","LOOP",0)="14735:28002:72005:100007"
+^ZZCOVERAGE("XINDX4","LOOP",0,"FOR_LOOP",1)=68121
+^ZZCOVERAGE("XINDX4","LOOP",1)="14735:4000:32003:36003"
+^ZZCOVERAGE("XINDX4","PAREN")="2638:24000:36004:60004"
+^ZZCOVERAGE("XINDX4","PAREN",0)="2638:4000:8000:12000"
+^ZZCOVERAGE("XINDX4","PAREN",1)="2638:20000:16001:36001"
+^ZZCOVERAGE("XINDX4","PAREN",1,"FOR_LOOP",1)=50171
+^ZZCOVERAGE("XINDX4","PAREN",2)="2638:0:8002:8002"
+^ZZCOVERAGE("XINDX4","PAREN",3)="2638:0:0:0"
+^ZZCOVERAGE("XINDX4","PRUNE")="2186:8001:16001:24002"
+^ZZCOVERAGE("XINDX4","PRUNE",0)="2186:8001:4000:12001"
+^ZZCOVERAGE("XINDX4","PRUNE",1)="2186:0:8001:8001"
+^ZZCOVERAGE("XINDX4","PRUNE",1,"FOR_LOOP",1)=2186
+^ZZCOVERAGE("XINDX4","PRUNE",2)="2186:0:4000:4000"
+^ZZCOVERAGE("XINDX4","PRUNE",2,"FOR_LOOP",1)=2187
+^ZZCOVERAGE("XINDX4","PRUNE",3)="2186:0:0:0"
+^ZZCOVERAGE("XINDX4","Q",1)="747:8000:0:8000"
+^ZZCOVERAGE("XINDX4","Q",2)="747:0:0:0"
+^ZZCOVERAGE("XINDX4","QUOTE")="2402:28002:28000:56002"
+^ZZCOVERAGE("XINDX4","QUOTE",0)="2402:20002:20000:40002"
+^ZZCOVERAGE("XINDX4","QUOTE",0,"FOR_LOOP",1)=23674
+^ZZCOVERAGE("XINDX4","QUOTE",1)="2402:0:0:0"
+^ZZCOVERAGE("XINDX4","QUOTE",2)="2402:8000:4000:12000"
+^ZZCOVERAGE("XINDX4","ST")="8937:24000:16002:40002"
+^ZZCOVERAGE("XINDX4","ST",0)="8937:12000:8000:20000"
+^ZZCOVERAGE("XINDX4","ST",1)="8937:8000:8002:16002"
+^ZZCOVERAGE("XINDX4","WR",0)="4584:12001:12000:24001"
+^ZZCOVERAGE("XINDX4","WR",1)="4584:0:8000:8000"
+^ZZCOVERAGE("XINDX4","WR",2)="4584:72004:56006:128010"
+^ZZCOVERAGE("XINDX4","WR",2,"FOR_LOOP",1)=27607
+^ZZCOVERAGE("XINDX4","WR",3)="23023:8002:32003:40005"
+^ZZCOVERAGE("XINDX4","WR",4)="20835:12000:32001:44001"
+^ZZCOVERAGE("XINDX4","WR",5)="20835:24002:8001:32003"
+^ZZCOVERAGE("XINDX4","WR",6)="20835:24000:36002:60002"
+^ZZCOVERAGE("XINDX4","WR",7)="20835:0:0:0"
+^ZZCOVERAGE("XINDX4","WR",8)="4584:4000:0:4000"
+^ZZCOVERAGE("XINDX4","XE",0)="220:0:0:0"
+^ZZCOVERAGE("XINDX4","XE",1)="220:0:0:0"
+^ZZCOVERAGE("XINDX5","A",0)="468:0:4000:4000"
+^ZZCOVERAGE("XINDX5","A",1)="467:28002:24000:52002"
+^ZZCOVERAGE("XINDX5","A",1,"FOR_LOOP",1)=4011
+^ZZCOVERAGE("XINDX5","A",2)="467:0:0:0"
+^ZZCOVERAGE("XINDX5","AA")="3544:48004:68006:116010"
+^ZZCOVERAGE("XINDX5","AA",0)="3544:8002:16003:24005"
+^ZZCOVERAGE("XINDX5","AA",1)="1902:0:4000:4000"
+^ZZCOVERAGE("XINDX5","AA",2)="1902:4001:0:4001"
+^ZZCOVERAGE("XINDX5","AA",3)="1902:12001:4001:16002"
+^ZZCOVERAGE("XINDX5","AA",4)="1902:12000:32002:44002"
+^ZZCOVERAGE("XINDX5","AA",5)="1902:0:0:0"
+^ZZCOVERAGE("XINDX5","AA",6)="1209:0:0:0"
+^ZZCOVERAGE("XINDX5","AA",7)="1209:8000:4000:12000"
+^ZZCOVERAGE("XINDX5","AA",8)="1209:0:0:0"
+^ZZCOVERAGE("XINDX5","AA",9)="1642:0:4000:4000"
+^ZZCOVERAGE("XINDX5","AA",10)="1594:0:0:0"
+^ZZCOVERAGE("XINDX5","AA",11)="1594:4000:4000:8000"
+^ZZCOVERAGE("XINDX5","AA",12)="1642:0:0:0"
+^ZZCOVERAGE("XINDX5","B",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","CLEAN",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","CLEAN",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","CLEAN",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","END",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","END",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","END",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","END",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","VTAG")="4320:12000:16001:28001"
+^ZZCOVERAGE("XINDX5","VTAG",0)="4320:12000:8001:20001"
+^ZZCOVERAGE("XINDX5","VTAG",1)="4320:0:4000:4000"
+^ZZCOVERAGE("XINDX5","XINDX5",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","XINDX5",4)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","XINDX5",5)="1:0:0:0"
+^ZZCOVERAGE("XINDX5","XINDX5",7)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","B")="1:0:4001:4001"
+^ZZCOVERAGE("XINDX51","B",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","B",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","B",3)="1:0:4001:4001"
+^ZZCOVERAGE("XINDX51","B",3,"FOR_LOOP",1)=468
+^ZZCOVERAGE("XINDX51","B",4)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","B",6)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","BHDR")="60:0:4000:4000"
+^ZZCOVERAGE("XINDX51","BHDR",0)="60:0:4000:4000"
+^ZZCOVERAGE("XINDX51","BHDR",1)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","END",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","HD")="60:0:0:0"
+^ZZCOVERAGE("XINDX51","HD",0)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","HD",1)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","HD1")="1:0:0:0"
+^ZZCOVERAGE("XINDX51","HD1",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","HD1",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","HD2")="60:4000:0:4000"
+^ZZCOVERAGE("XINDX51","HD2",0)="60:4000:0:4000"
+^ZZCOVERAGE("XINDX51","HD2",1)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","WAIT")="1:0:0:0"
+^ZZCOVERAGE("XINDX51","WAIT",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","WAIT",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","WAIT",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR")="60:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",0)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",1)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",2)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",2,"FOR_LOOP",1)=135
+^ZZCOVERAGE("XINDX51","WERR",3)="75:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",4)="75:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",5)="75:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",6)="75:0:0:0"
+^ZZCOVERAGE("XINDX51","WERR",7)="60:0:0:0"
+^ZZCOVERAGE("XINDX51","WORL")="70:0:0:0"
+^ZZCOVERAGE("XINDX51","WORL",0)="70:0:0:0"
+^ZZCOVERAGE("XINDX51","WORL",1)="70:0:0:0"
+^ZZCOVERAGE("XINDX51","WORL",2)="70:0:0:0"
+^ZZCOVERAGE("XINDX51","WORL",3)="70:0:0:0"
+^ZZCOVERAGE("XINDX51","WORL",3,"FOR_LOOP",1)=76
+^ZZCOVERAGE("XINDX51","WORL",4)="70:0:0:0"
+^ZZCOVERAGE("XINDX52","CASE")="2:0:0:0"
+^ZZCOVERAGE("XINDX52","CASE",0)="2:0:0:0"
+^ZZCOVERAGE("XINDX52","CASE",1)="2:0:0:0"
+^ZZCOVERAGE("XINDX6","ANS")="2:0:0:0"
+^ZZCOVERAGE("XINDX6","ANS",0)="2:0:0:0"
+^ZZCOVERAGE("XINDX6","ANS",1)="2:0:0:0"
+^ZZCOVERAGE("XINDX6","ANS",1,"FOR_LOOP",1)=2
+^ZZCOVERAGE("XINDX6","ANS",2)="2:0:0:0"
+^ZZCOVERAGE("XINDX6","ASKRTN")="1:4000:0:4000"
+^ZZCOVERAGE("XINDX6","ASKRTN",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","ASKRTN",1,"FOR_LOOP",1)=468
+^ZZCOVERAGE("XINDX6","ASKRTN",2)="1:4000:0:4000"
+^ZZCOVERAGE("XINDX6","ASKRTN",2,"FOR_LOOP",1)=468
+^ZZCOVERAGE("XINDX6","ASKRTN",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","DEVICE",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","DEVICE",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","DEVICE",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","L7",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","L7",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","NY")="1:0:0:0"
+^ZZCOVERAGE("XINDX6","NY",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM")="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM",2,"FOR_LOOP",1)=10
+^ZZCOVERAGE("XINDX6","PARAM",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM",4)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM",5)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM",6)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","PARAM",7)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","RD")="2:0:0:0"
+^ZZCOVERAGE("XINDX6","RD",0)="2:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",5)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",6)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",7)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",8)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",9)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",10)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",11)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",12)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","XINDX6",13)="1:0:0:0"
+^ZZCOVERAGE("XINDX6","YN")="1:0:0:0"
+^ZZCOVERAGE("XINDX6","YN",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD")="1:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",0)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",1,"FOR_LOOP",1)=10
+^ZZCOVERAGE("XINDX7","BUILD",2)="9:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",3)="6:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",3,"FOR_LOOP",1)=85
+^ZZCOVERAGE("XINDX7","BUILD",4)="79:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",5)="79:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",6)="6:0:0:0"
+^ZZCOVERAGE("XINDX7","BUILD",7)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR")="2:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",0)="2:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",1)="2:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",4)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",5)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",6)="2:0:0:0"
+^ZZCOVERAGE("XINDX7","HDR",7)="2:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP")="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",1)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",2)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",3)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",4)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",6)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",7)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",7,"FOR_LOOP",1)=468
+^ZZCOVERAGE("XINDX7","SETUP",8)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",9)="1:0:0:0"
+^ZZCOVERAGE("XINDX7","SETUP",10)="1:0:0:0"
+^ZZCOVERAGE("XINDX9","ADD")="406841:436032:684041:1120073"
+^ZZCOVERAGE("XINDX9","ADD",0)="598820:552042:692040:1244082"
+^ZZCOVERAGE("XINDX9","AR")="197699:748039:1052073:1800112"
+^ZZCOVERAGE("XINDX9","AR",0)="197699:708036:936061:1644097"
+^ZZCOVERAGE("XINDX9","CASE")="23461:28003:92005:120008"
+^ZZCOVERAGE("XINDX9","CASE",0)="23461:12002:48003:60005"
+^ZZCOVERAGE("XINDX9","CASE",1)="23461:12001:28000:40001"
+^ZZCOVERAGE("XINDX9","DN")="45002:204010:248016:452026"
+^ZZCOVERAGE("XINDX9","DN",0)="45002:176008:196011:372019"
+^ZZCOVERAGE("XINDX9","DN",1)="45002:16001:24003:40004"
+^ZZCOVERAGE("XINDX9","EXT",1)="1970:4000:12001:16001"
+^ZZCOVERAGE("XINDX9","FNC")="29146:96005:104009:200014"
+^ZZCOVERAGE("XINDX9","FNC",0)="29146:28001:20003:48004"
+^ZZCOVERAGE("XINDX9","FNC",1)="29146:44002:72005:116007"
+^ZZCOVERAGE("XINDX9","FNC",2)="12:0:0:0"
+^ZZCOVERAGE("XINDX9","FNC",3)="12:0:0:0"
+^ZZCOVERAGE("XINDX9","FUNC")="29134:284015:400024:684039"
+^ZZCOVERAGE("XINDX9","FUNC",1)="29134:112005:120007:232012"
+^ZZCOVERAGE("XINDX9","FUNC",2)="23461:48003:72004:120007"
+^ZZCOVERAGE("XINDX9","FUNC",3)="23461:20000:32001:52001"
+^ZZCOVERAGE("XINDX9","FX",0)="23461:68004:116009:184013"
+^ZZCOVERAGE("XINDX9","GVAR")="29134:96004:180015:276019"
+^ZZCOVERAGE("XINDX9","GVAR",0)="29134:28000:44003:72003"
+^ZZCOVERAGE("XINDX9","GVAR",1)="29134:32001:72005:104006"
+^ZZCOVERAGE("XINDX9","GVAR",2)="29134:16000:24002:40002"
+^ZZCOVERAGE("XINDX9","INC")="29134:64003:64007:128010"
+^ZZCOVERAGE("XINDX9","INC",0)="29134:20001:12001:32002"
+^ZZCOVERAGE("XINDX9","INC",1)="29134:32002:40004:72006"
+^ZZCOVERAGE("XINDX9","NEW")="287703:532032:660032:1192064"
+^ZZCOVERAGE("XINDX9","NEW",0)="287703:200012:244014:444026"
+^ZZCOVERAGE("XINDX9","NEW",1)="287703:220014:248008:468022"
+^ZZCOVERAGE("XINDX9","NUM")="45379:292023:340026:632049"
+^ZZCOVERAGE("XINDX9","NUM",0)="45379:92006:84006:176012"
+^ZZCOVERAGE("XINDX9","NUM",0,"FOR_LOOP",1)=71145
+^ZZCOVERAGE("XINDX9","NUM",1)="45379:40005:48002:88007"
+^ZZCOVERAGE("XINDX9","NUM",2)="45379:40004:56005:96009"
+^ZZCOVERAGE("XINDX9","NUM",3)="45379:76003:88008:164011"
+^ZZCOVERAGE("XINDX9","NUM",4)="45379:24003:40003:64006"
+^ZZCOVERAGE("XINDX9","PA2",0)="518346:544028:668032:1212060"
+^ZZCOVERAGE("XINDX9","PA2",1)="472665:532043:620035:1152078"
+^ZZCOVERAGE("XINDX9","PA2",2)="317803:264019:292021:556040"
+^ZZCOVERAGE("XINDX9","PA2",3)="317803:200013:324018:524031"
+^ZZCOVERAGE("XINDX9","PA2",4)="307072:348020:492025:840045"
+^ZZCOVERAGE("XINDX9","PA2",5)="197397:160015:296011:456026"
+^ZZCOVERAGE("XINDX9","PA2",6)="152018:120016:132005:252021"
+^ZZCOVERAGE("XINDX9","PA2",7)="152018:116009:112008:228017"
+^ZZCOVERAGE("XINDX9","PA2",8)="151813:96008:168010:264018"
+^ZZCOVERAGE("XINDX9","PA2",9)="151813:100008:172009:272017"
+^ZZCOVERAGE("XINDX9","PA2",10)="151813:220008:324022:544030"
+^ZZCOVERAGE("XINDX9","PA2",11)="151813:168011:152010:320021"
+^ZZCOVERAGE("XINDX9","PA2",12)="151813:128009:148012:276021"
+^ZZCOVERAGE("XINDX9","PA2",13)="151813:136005:104009:240014"
+^ZZCOVERAGE("XINDX9","PARSE")="45681:3356226:4340257:7696483"
+^ZZCOVERAGE("XINDX9","PARSE",0)="45681:104007:108007:212014"
+^ZZCOVERAGE("XINDX9","PAT")="205:0:0:0"
+^ZZCOVERAGE("XINDX9","PAT",0)="205:0:0:0"
+^ZZCOVERAGE("XINDX9","PAT",1)="205:0:0:0"
+^ZZCOVERAGE("XINDX9","PAT",1,"FOR_LOOP",1)=1185
+^ZZCOVERAGE("XINDX9","PAT",2)="205:0:0:0"
+^ZZCOVERAGE("XINDX9","PAT",3)="205:0:0:0"
+^ZZCOVERAGE("XINDX9","PAT",4)="205:0:0:0"
+^ZZCOVERAGE("XINDX9","PATC")="28:0:0:0"
+^ZZCOVERAGE("XINDX9","PATC",0)="28:0:0:0"
+^ZZCOVERAGE("XINDX9","PATQ")="99:0:8000:8000"
+^ZZCOVERAGE("XINDX9","PATQ",0)="99:0:0:0"
+^ZZCOVERAGE("XINDX9","PATQ",0,"FOR_LOOP",1)=247
+^ZZCOVERAGE("XINDX9","PATQ",1)="99:0:0:0"
+^ZZCOVERAGE("XINDX9","PATQ",2)="99:0:8000:8000"
+^ZZCOVERAGE("XINDX9","PATU")="15:0:0:0"
+^ZZCOVERAGE("XINDX9","PATU",0)="15:0:0:0"
+^ZZCOVERAGE("XINDX9","PEND",0)="45681:68001:140014:208015"
+^ZZCOVERAGE("XINDX9","PEND",1)="45681:36004:52005:88009"
+^ZZCOVERAGE("XINDX9","QUOTE")="35724:244013:304019:548032"
+^ZZCOVERAGE("XINDX9","QUOTE",0)="36272:172010:140009:312019"
+^ZZCOVERAGE("XINDX9","QUOTE",0,"FOR_LOOP",1)=323021
+^ZZCOVERAGE("XINDX9","QUOTE",1)="36272:28001:72004:100005"
+^ZZCOVERAGE("XINDX9","QUOTE",2)="35724:28001:24003:52004"
+^ZZCOVERAGE("XINDX9","QUOTE",3)="35724:16001:52002:68003"
+^ZZCOVERAGE("XINDX9","SPV",0)="3703:4000:12000:16000"
+^ZZCOVERAGE("XINDX9","SPV",1)="3703:8001:4000:12001"
+^ZZCOVERAGE("XINDX9","SPV",2)="3703:8001:4000:12001"
+^ZZCOVERAGE("XINDX9","SPV",3)="3703:4000:8001:12001"
+^ZZCOVERAGE("XINDX9","STR")="287703:560037:724043:1284080"
+^ZZCOVERAGE("XINDX9","STR",0)="287703:300018:312020:612038"
+^ZZCOVERAGE("XINDX9","SUM")="213322:612034:916052:1528086"
+^ZZCOVERAGE("XINDX9","SUM",0)="213322:160009:208011:368020"
+^ZZCOVERAGE("XINDX9","SUM",1)="213322:212007:280018:492025"
+^ZZCOVERAGE("XINDX9","SUM",2)="213322:136012:268012:404024"
+^ZZCOVERAGE("XINDX9","UP")="45002:396026:440029:836055"
+^ZZCOVERAGE("XINDX9","UP",0)="45002:24003:44001:68004"
+^ZZCOVERAGE("XINDX9","UP",1)="45002:180008:192016:372024"
+^ZZCOVERAGE("XINDX9","UP",2)="45002:136010:128005:264015"
+^ZZCOVERAGE("XINDX9","UP",3)="45002:40003:52003:92006"
+^ZZCOVERAGE("XINDX9","VAR")="138809:828044:1004072:1832116"
+^ZZCOVERAGE("XINDX9","VAR",0)="138809:376018:336017:712035"
+^ZZCOVERAGE("XINDX9","VAR",0,"FOR_LOOP",1)=462128
+^ZZCOVERAGE("XINDX9","VAR",1)="138809:292018:376034:668052"
+^ZZCOVERAGE("XINDX9","VAR",2)="138809:116003:144008:260011"
+^ZZCOVERAGE("XINDX9","XINDX9")="45681:296016:320021:616037"
+^ZZCOVERAGE("XINDX9","XINDX9",3)="45681:52003:128006:180009"
+^ZZCOVERAGE("XINDX9","XINDX9",4)="45681:164006:112008:276014"
+^ZZCOVERAGE("XINDX9","XINDX9",4,"FOR_LOOP",1)=128269
+^ZZCOVERAGE("XINDX9","XINDX9",5)="45681:48004:52005:100009"
+^ZZCOVERAGE("XLFDT","DT")="1:0:0:0"
+^ZZCOVERAGE("XLFDT","DT",0)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","DT",1)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","HR")="3:0:0:0"
+^ZZCOVERAGE("XLFDT","HR",0)="3:0:0:0"
+^ZZCOVERAGE("XLFDT","HR",1)="3:0:0:0"
+^ZZCOVERAGE("XLFDT","HTE")="1:0:0:0"
+^ZZCOVERAGE("XLFDT","HTE",0)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","HTE",1)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","HTE",2)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","HTE",3)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","HTFM")="2:0:0:0"
+^ZZCOVERAGE("XLFDT","HTFM",0)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","HTFM",1)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","HTFM",2)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","HTFM",3)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","HTFM",4)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","HTFM",5)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","T2",0)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","T2",1)="1:0:0:0"
+^ZZCOVERAGE("XLFDT","YMD")="2:0:0:0"
+^ZZCOVERAGE("XLFDT","YMD",1)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","YMD",2)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","YMD",3)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","YMD",4)="2:0:0:0"
+^ZZCOVERAGE("XLFDT","YMD",5)="2:0:0:0"
+^ZZCOVERAGE("XLFDT1","F1",1)="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","FMT")="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","FMT",1)="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","FMT",2)="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","M")="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","M",0)="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","TM",1)="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","TM",2)="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","TM",3)="1:0:0:0"
+^ZZCOVERAGE("XLFDT1","TM",7)="1:0:0:0"
+^ZZCOVERAGE("XPDRSUM","SUMB")="467:1808124:180014:1988138"
+^ZZCOVERAGE("XPDRSUM","SUMB",0)="467:8000:0:8000"
+^ZZCOVERAGE("XPDRSUM","SUMB",2)="467:0:0:0"
+^ZZCOVERAGE("XPDRSUM","SUMB",3)="467:1796124:180014:1976138"
+^ZZCOVERAGE("XPDRSUM","SUMB",3,"FOR_LOOP",1)=44620
+^ZZCOVERAGE("XPDRSUM","SUMB",3,"FOR_LOOP",2)=1566704
+^ZZCOVERAGE("XPDRSUM","SUMB",4)="467:0:0:0"
+^ZZCOVERAGE("XTRUTL1","BUILD")="1:0:0:0"
+^ZZCOVERAGE("XTRUTL1","BUILD",0)="1:0:0:0"
+^ZZCOVERAGE("XTRUTL1","BUILD",1)="1:0:0:0"
+^ZZCOVERAGE("XTRUTL1","BUILD",2)="1:0:0:0"
+^ZZCOVERAGE("XTRUTL1","BUILD",3)="1:0:0:0"
+
+
diff --git a/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in b/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in
new file mode 100644
index 0000000..a1c6b17
--- /dev/null
+++ b/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in
@@ -0,0 +1,8 @@
+# This file is configured by CMake automatically as DartConfiguration.tcl
+# If you choose not to use CMake, this file may be hand configured, by
+# filling in the required variables.
+
+
+# Configuration directories and files
+SourceDirectory: ${CMake_SOURCE_DIR}/Testing/MumpsCoverage
+BuildDirectory: ${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage
diff --git a/Tests/MumpsCoverage/DartConfiguration.tcl.in b/Tests/MumpsCoverage/DartConfiguration.tcl.in
new file mode 100644
index 0000000..2d7eaa5
--- /dev/null
+++ b/Tests/MumpsCoverage/DartConfiguration.tcl.in
@@ -0,0 +1,8 @@
+# This file is configured by CMake automatically as DartConfiguration.tcl
+# If you choose not to use CMake, this file may be hand configured, by
+# filling in the required variables.
+
+
+# Configuration directories and files
+SourceDirectory: ${CMake_SOURCE_DIR}/Testing/MumpsCoverage
+BuildDirectory: ${CMake_BINARY_DIR}/Testing/MumpsCoverage
diff --git a/Tests/MumpsCoverage/VistA-FOIA/Packages/Toolkit/Routines/XINDEX.m b/Tests/MumpsCoverage/VistA-FOIA/Packages/Toolkit/Routines/XINDEX.m
new file mode 100644
index 0000000..b045221
--- /dev/null
+++ b/Tests/MumpsCoverage/VistA-FOIA/Packages/Toolkit/Routines/XINDEX.m
@@ -0,0 +1,144 @@
+XINDEX ;ISC/REL,GFT,GRK,RWF - INDEX & CROSS-REFERENCE ;08/04/08  13:19
+ ;;7.3;TOOLKIT;**20,27,48,61,66,68,110,121,128**;Apr 25, 1995;Build 1
+ ; Per VHA Directive 2004-038, this routine should not be modified.
+ G ^XINDX6
+SEP F I=1:1 S CH=$E(LIN,I) D QUOTE:CH=Q Q:" "[CH
+ S ARG=$E(LIN,1,I-1) S:CH=" " I=I+1 S LIN=$E(LIN,I,999) Q
+QUOTE F I=I+1:1 S CH=$E(LIN,I) Q:CH=""!(CH=Q)
+ Q:CH]""  S ERR=6 G ^XINDX1
+ALIVE ;enter here from taskman
+ D SETUP^XINDX7 ;Get ready to process
+A2 S RTN=$O(^UTILITY($J,RTN)) G ^XINDX5:RTN=""
+ S INDLC=(RTN?1"|"1.4L.NP) D LOAD:'INDLC
+ I $D(ZTQUEUED),$$S^%ZTLOAD S RTN="~",IND("QUIT")=1,ZTSTOP=1 G A2
+ I 'INDDS,INDLC W !!?10,"Data Dictionaries",! S INDDS=1
+ D BEG
+ G A2
+ ;
+LOAD S X=RTN,XCNP=0,DIF="^UTILITY("_$J_",1,RTN,0," X ^%ZOSF("TEST") Q:'$T  X ^%ZOSF("LOAD") S ^UTILITY($J,1,RTN,0,0)=XCNP-1
+ I $D(^UTILITY($J,1,RTN,0,0)) S ^UTILITY($J,1,RTN,"RSUM")="B"_$$SUMB^XPDRSUM($NA(^UTILITY($J,1,RTN,0)))
+ Q
+BEG ;
+ S %=INDLC*5 W:$X+10+%>IOM ! W RTN,$J("",10+%-$L(RTN))
+ S (IND("DO"),IND("SZT"),IND("SZC"),LABO)=0,LC=$G(^UTILITY($J,1,RTN,0,0))
+ I LC="" W !,">>>Routine '",RTN,"' not found <<<",! Q
+ S TXT="",LAB=$P(^UTILITY($J,1,RTN,0,1,0)," ") I RTN'=$P(LAB,"(") D E^XINDX1(17)
+ I 'INDLC,LAB["(" D E^XINDX1(55) S LAB=$P(LAB,"(")
+ ;if M routine(not compiled template or DD) and has more than 2 lines, check lines 1 & 2
+ I 'INDLC,LC>2 D
+ . N LABO S LABO=1
+ . S LIN=$G(^UTILITY($J,1,RTN,0,1,0)),TXT=1
+ . ;check 1st line (site/dev - ) patch 128
+ . I $P(LIN,";",2,4)'?.E1"/".E.1"-".E D E^XINDX1(62)
+ . S LIN=$G(^UTILITY($J,1,RTN,0,2,0)),TXT=2
+ . ;check 2nd line (;;nn.nn[TV]nn;package;.anything)
+ . I $P(LIN,";",3,99)'?1.2N1"."1.2N.1(1"T",1"V").2N1";"1A.AP1";".E D E^XINDX1(44) ;patch 121
+ . I $L(INP(11)) X INP(11) ;Version number check
+ . I $L(INP(12)) X INP(12) ;Patch number check
+B5 F TXT=1:1:LC S LIN=^UTILITY($J,1,RTN,0,TXT,0),LN=$L(LIN),IND("SZT")=IND("SZT")+LN+2 D LN,ST ;Process Line
+ S LAB="",LABO=0,TXT=0,^UTILITY($J,1,RTN,0)=IND("SZT")_"^"_LC_"^"_IND("SZC")
+ I IND("SZT")>INP("MAX"),'INDLC S ERR=35,ERR(1)=IND("SZT") D ^XINDX1
+ I IND("SZT")-IND("SZC")>INP("CMAX"),'INDLC S ERR=58,ERR(1)=IND("SZT")-IND("SZC") D ^XINDX1
+ D POSTRTN
+ Q
+ ;Proccess one line, LN = Length, LIN = Line.
+LN K V S (ARG,GRB,IND("COM"),IND("DOL"),IND("F"))="",X=$P(LIN," ")
+ I '$L(X) S LABO=LABO+1 G CD
+ S (IND("COM"),LAB)=$P(X,"("),ARG=$P($P(X,"(",2),")"),LABO=0,IND("PP")=X?1.8E1"(".E1")"
+ D:$L(ARG) NE^XINDX3 ;Process formal parameters as New list.
+ I 'INDLC,'$$VT^XINDX2(LAB) D E^XINDX1($S(LAB=$$CASE^XINDX52(LAB):37,1:55)) ;Check for bad labels
+ I $D(^UTILITY($J,1,RTN,"T",LAB)) D E^XINDX1(15) G CD ;DUP label
+ S ^UTILITY($J,1,RTN,"T",LAB)=""
+CD I LN>245 D:'(LN=246&($E(RTN,1,3)="|dd")) E^XINDX1(19) ;patch 119
+ D:LIN'?1.ANP E^XINDX1(18)
+ S LIN=$P(LIN," ",2,999),IND("LCC")=1
+ I LIN="" D E^XINDX1(42) Q  ;Blank line ;p110
+ S I=0 ;Watch the scope of I, counts dots
+ I " ."[$E(LIN) D  S X=$L($E(LIN,1,I),".")-1,LIN=$E(LIN,I,999)
+ . F I=1:1:245 Q:". "'[$E(LIN,I)
+ . Q
+ ;check dots against Do level IND("DO"), IND("DOL")=dot level
+ D:'I&$G(IND("DO1")) E^XINDX1(51) S IND("DO1")=0 S:'I IND("DO")=0
+ I I D:X>IND("DO") E^XINDX1(51) S (IND("DO"),IND("DOL"))=X
+ ;Count Comment lines, skip ;; lines
+ I $E(LIN)=";",$E(LIN,2)'=";" S IND("SZC")=IND("SZC")+$L(LIN) ;p110
+ ;Process commands on line.
+EE I LIN="" D ^XINDX2 Q
+ S COM=$E(LIN),GK="",ARG=""
+ I COM=";" S LIN="" G EE ;p110
+ I COM=" " S ERR=$S(LIN?1." ":13,1:0),LIN=$S(ERR:"",1:$E(LIN,2,999)) D:ERR ^XINDX1 G EE
+ D SEP
+ S CM=$P(ARG,":",1),POST=$P(ARG,":",2,999),IND("COM")=IND("COM")_$C(9)_COM,ERR=48
+ D:ARG[":"&(POST']"") ^XINDX1 S:POST]"" GRB=GRB_$C(9)_POST,IND("COM")=IND("COM")_":"
+ ;SAC now allows lowercase commands
+ I CM?.E1L.E S CM=$$CASE^XINDX52(CM),COM=$E(CM) ;I IND("LCC") S IND("LCC")=0 D E^XINDX1(47)
+ I CM="" D E^XINDX1(21) G EE ;Missing command
+ S CX=$G(IND("CMD",CM)) I CX="" D  G:CX="" EE
+ . I $E(CM)="Z" S CX="^Z" Q  ;Proccess Z commands
+ . D E^XINDX1(1) S LIN="" Q
+ S CX=$P(CX,"^",2,9)
+ D SEP I '$L(LIN),CH=" " D E^XINDX1(13) ;trailing space
+ I ARG="","CGJMORSUWX"[COM S ERR=49 G ^XINDX1
+ I CX>0 D E^XINDX1(CX) S CX=""
+ D:$L(CX) @CX S:ARG'="" GRB=GRB_$C(9)_ARG G EE
+B S ERR=25 G ^XINDX1
+C S ERR=29 G ^XINDX1
+D G DG1^XINDX4
+E Q:ARG=""  S ERR=7 G ^XINDX1
+F G:ARG]"" FR^XINDX4 S IND("F")=1 Q
+G G DG^XINDX4
+H Q:ARG'=""  S ERR=32 G ^XINDX1
+J S ERR=36,ARG="" G ^XINDX1
+K S ERR=$S(ARG?1"(".E:22,ARG?." ":23,1:0) D:ERR ^XINDX1
+ G KL^XINDX3
+L G LO^XINDX4
+M G S^XINDX3
+N G NE^XINDX3
+O S ERR=34 D ^XINDX1,O^XINDX3 Q
+Q Q:ARG=""  G Q^XINDX4
+R S RDTIME=0 G RD^XINDX3
+S G S^XINDX3
+TR Q  ;What to process. p110
+U S ARG=$P(ARG,":") Q
+V S ARG="",ERR=20 G ^XINDX1
+W G WR^XINDX4
+X G XE^XINDX4
+Z S ERR=2 D ^XINDX1 G ZC^XINDX4
+ ;
+ ;Save off items from line.
+ST S R=LAB_$S(LABO:"+"_LABO,1:"")
+ ;Local variable, Global, Marked Items, Naked global, Internal ref, eXternal ref., Tag ref.
+ S LOC="" F  S LOC=$O(V(LOC)),S="" Q:LOC=""  F  S S=$O(V(LOC,S)) Q:S=""  D SET
+ S ^UTILITY($J,1,RTN,"COM",TXT)=IND("COM")
+ Q
+ ;
+SET I V(LOC,S)]"" F %="!","~" I V(LOC,S)[%,$G(^UTILITY($J,1,RTN,LOC,S))'[% S ^(S)=$G(^(S))_%
+ S %=0
+SE2 S ARG=$G(^UTILITY($J,1,RTN,LOC,S,%)) I $L(ARG)>230 S %=%+1 G SE2
+ S ^UTILITY($J,1,RTN,LOC,S,%)=ARG_R_V(LOC,S)_","
+ Q
+ ;
+POSTRTN ;Do more overall checking
+ N V,E,T,T1,T2
+ S T="" ;Check for missing Labels
+ F  S T=$O(^UTILITY($J,1,RTN,"I",T)),T2=T Q:T=""  S T1=$G(^(T,0)) D
+ . Q:$E(T2,1,2)="@("
+ . S:$E(T2,1,2)="$$" T2=$E(T2,3,99)
+ . I T2]"",'$D(^UTILITY($J,1,RTN,"T",$P(T2,"+",1))) D
+ . . F I=1:1:$L(T1,",")-1 S LAB=$P(T1,",",I),LABO=+$P(LAB,"+",2),LAB=$P(LAB,"+"),E=14,E(1)=T D E^XINDX1(.E)
+ . . Q
+ . Q
+ S LAB="",LABO=0 ;Check for valid label names
+ I 'INDLC F  S LAB=$O(^UTILITY($J,1,RTN,"T",LAB)) Q:LAB=""  D
+ . I '$$VA^XINDX2(LAB) D E^XINDX1(55) Q
+ . D:'$$VT^XINDX2(LAB) E^XINDX1(37)
+ . Q
+ S LAB="",LABO=0 ;Check for valid variable names.
+ F  S LAB=$O(^UTILITY($J,1,RTN,"L",LAB)) Q:LAB=""  D
+ . D VLNF^XINDX3($P(LAB,"("))
+ . Q
+ Q
+ ;
+QUICK ;Quick, Just get a routine an print the results
+ D QUICK^XINDX6()
+ Q
diff --git a/Tests/MumpsCoverage/cache_coverage.cmcov.in b/Tests/MumpsCoverage/cache_coverage.cmcov.in
new file mode 100644
index 0000000..b431dbd
--- /dev/null
+++ b/Tests/MumpsCoverage/cache_coverage.cmcov.in
@@ -0,0 +1,2 @@
+packages:${CMake_BINARY_DIR}/Testing/MumpsCoverage/VistA-FOIA/Packages
+coverage_dir:${CMake_SOURCE_DIR}/Tests/MumpsCoverage
diff --git a/Tests/MumpsCoverage/gtm_coverage.mcov.in b/Tests/MumpsCoverage/gtm_coverage.mcov.in
new file mode 100644
index 0000000..b431dbd
--- /dev/null
+++ b/Tests/MumpsCoverage/gtm_coverage.mcov.in
@@ -0,0 +1,2 @@
+packages:${CMake_BINARY_DIR}/Testing/MumpsCoverage/VistA-FOIA/Packages
+coverage_dir:${CMake_SOURCE_DIR}/Tests/MumpsCoverage