From 2ca0172767a1df5d607042701654a5ffca842e07 Mon Sep 17 00:00:00 2001 From: David Dieppois <75264909+ddieppois@users.noreply.github.com> Date: Fri, 3 May 2024 12:21:12 -0400 Subject: [PATCH] Versioning and NewRefreshIg Merge (#526) * Versioning and NewRefreshIg Merge * Revert test * Updating refresh TerserUtil usage to clear field before update * Update * Added test cases for external reference and Versioning * Added test cases for external reference and Versioning 2 * Reduced test IG Size * Reduced test IG Size and update location * Removed use of Junit, replaced my TestNg Framework * Using afterSuite instead of method * Test update * Fix paths * Fix urls --------- Co-authored-by: c-schuler Co-authored-by: JP --- .../tooling/operation/ig/LibraryRefresh.java | 7 +- .../operation/ig/NewRefreshIGOperation.java | 2 +- .../cqf/tooling/operation/ig/Refresh.java | 10 + .../parameter/RefreshIGParameters.java | 1 + .../argument/RefreshIGArgumentProcessor.java | 11 +- .../org/opencds/cqf/tooling/RefreshTest.java | 3 +- .../operation/RefreshIGOperationTest.java | 6 +- .../src/test/resources/NewRefreshIG/ig.ini | 4 + .../resources/NewRefreshIG/input/cqf-us.xml | 134 ++++ .../cql/CumulativeMedicationDuration.cql | 596 +++++++++++++++++ .../input/cql/GMTPInitialExpressions.cql | 237 +++++++ .../input/cql/MBODAInitialExpressions.cql | 248 +++++++ .../input/cql/UPPARFInitialExpressions.cql | 225 +++++++ .../NewRefreshIG/input/cql/USCoreCommon.cql | 628 ++++++++++++++++++ .../NewRefreshIG/input/cql/USCoreElements.cql | 384 +++++++++++ .../NewRefreshIG/input/cql/USCoreTests.cql | 98 +++ .../NewRefreshIG/input/cql/cql-options.json | 16 + .../library-CumulativeMedicationDuration.json | 69 ++ .../library-GMTPInitialExpressions.json | 487 ++++++++++++++ .../library-MBODAInitialExpressions.json | 470 +++++++++++++ .../library/library-USCore-ModelInfo.json | 53 ++ .../library/library-USCoreCommon.json | 127 ++++ .../library/library-USCoreElements.json | 542 +++++++++++++++ .../library/library-USCoreTests.json | 520 +++++++++++++++ 24 files changed, 4869 insertions(+), 9 deletions(-) create mode 100644 tooling/src/test/resources/NewRefreshIG/ig.ini create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cqf-us.xml create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/CumulativeMedicationDuration.cql create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/GMTPInitialExpressions.cql create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/MBODAInitialExpressions.cql create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/UPPARFInitialExpressions.cql create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/USCoreCommon.cql create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/USCoreElements.cql create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/USCoreTests.cql create mode 100644 tooling/src/test/resources/NewRefreshIG/input/cql/cql-options.json create mode 100644 tooling/src/test/resources/NewRefreshIG/input/resources/library/library-CumulativeMedicationDuration.json create mode 100644 tooling/src/test/resources/NewRefreshIG/input/resources/library/library-GMTPInitialExpressions.json create mode 100644 tooling/src/test/resources/NewRefreshIG/input/resources/library/library-MBODAInitialExpressions.json create mode 100644 tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCore-ModelInfo.json create mode 100644 tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreCommon.json create mode 100644 tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreElements.json create mode 100644 tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreTests.json diff --git a/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/LibraryRefresh.java b/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/LibraryRefresh.java index 8441d7cdb..13d8a5957 100644 --- a/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/LibraryRefresh.java +++ b/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/LibraryRefresh.java @@ -14,6 +14,7 @@ import org.hl7.fhir.utilities.npm.NpmPackage; import org.opencds.cqf.tooling.npm.LibraryLoader; import org.opencds.cqf.tooling.npm.NpmPackageManager; +import org.opencds.cqf.tooling.parameter.RefreshIGParameters; import org.opencds.cqf.tooling.processor.CqlProcessor; import org.opencds.cqf.tooling.utilities.CanonicalUtils; import org.opencds.cqf.tooling.utilities.IOUtils; @@ -48,9 +49,12 @@ public LibraryRefresh(IGInfo igInfo) { Collections.singletonList(igInfo.getCqlBinaryPath()), libraryLoader, new IGLoggingService(logger), ucumService, igInfo.getPackageId(), igInfo.getCanonical(), true); } - @Override public List refresh() { + return refresh(null); + } + + public List refresh(RefreshIGParameters params) { List refreshedLibraries = new ArrayList<>(); this.cqlProcessor.execute(); if (getIgInfo().isRefreshLibraries()) { @@ -72,6 +76,7 @@ public List refresh() { refreshDataRequirements(library, info); refreshRelatedArtifacts(library, info); refreshParameters(library, info); + refreshVersion(library, params); refreshedLibraries.add(library); this.libraryPackages.add(new LibraryPackage(library, getFhirContext(), info)); } diff --git a/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/NewRefreshIGOperation.java b/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/NewRefreshIGOperation.java index 0601d8dfd..23e3c4678 100644 --- a/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/NewRefreshIGOperation.java +++ b/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/NewRefreshIGOperation.java @@ -23,7 +23,7 @@ public void execute(String[] args) { this.params = new RefreshIGArgumentProcessor().parseAndConvert(args); IGInfo info = new IGInfo(null, params); LibraryRefresh libraryRefresh = new LibraryRefresh(info); - publishLibraries(info, libraryRefresh.refresh()); + publishLibraries(info, libraryRefresh.refresh(this.params)); PlanDefinitionRefresh planDefinitionRefresh = new PlanDefinitionRefresh(info, libraryRefresh.getCqlProcessor(), libraryRefresh.getLibraryPackages()); publishPlanDefinitions(info, planDefinitionRefresh.refresh()); if (!planDefinitionRefresh.getPlanDefinitionPackages().isEmpty()) { diff --git a/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/Refresh.java b/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/Refresh.java index 37429e748..3b36774ee 100644 --- a/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/Refresh.java +++ b/tooling/src/main/java/org/opencds/cqf/tooling/operation/ig/Refresh.java @@ -7,6 +7,7 @@ import org.hl7.fhir.instance.model.api.IBaseBundle; import org.hl7.fhir.instance.model.api.IBaseResource; import org.hl7.fhir.r5.model.*; +import org.opencds.cqf.tooling.parameter.RefreshIGParameters; import org.opencds.cqf.tooling.utilities.BundleUtils; import org.opencds.cqf.tooling.utilities.constants.CqfmConstants; import org.opencds.cqf.tooling.utilities.converters.ResourceAndTypeConverter; @@ -29,10 +30,19 @@ public Refresh(IGInfo igInfo) { public abstract List refresh(); public void refreshDate(IBaseResource resource) { + TerserUtil.clearField(getIgInfo().getFhirContext(), "date", resource); TerserUtil.setField(getIgInfo().getFhirContext(), "date", resource, ResourceAndTypeConverter.convertType(getFhirContext(), new DateTimeType(new Date()))); } + public void refreshVersion(IBaseResource resource, RefreshIGParameters params) { + if (params != null && params.updatedVersion != null && !params.updatedVersion.isEmpty()) { + TerserUtil.clearField(getIgInfo().getFhirContext(), "version", resource); + TerserUtil.setField(getIgInfo().getFhirContext(), "version", resource, + ResourceAndTypeConverter.convertType(getFhirContext(), new StringType(params.updatedVersion))); + } + } + public void validatePrimaryLibraryReference(IBaseResource resource) { if ((resource instanceof PlanDefinition && !((PlanDefinition) resource).hasLibrary()) || (resource instanceof Measure && !((Measure) resource).hasLibrary())) { diff --git a/tooling/src/main/java/org/opencds/cqf/tooling/parameter/RefreshIGParameters.java b/tooling/src/main/java/org/opencds/cqf/tooling/parameter/RefreshIGParameters.java index e46d272ef..d7f138190 100644 --- a/tooling/src/main/java/org/opencds/cqf/tooling/parameter/RefreshIGParameters.java +++ b/tooling/src/main/java/org/opencds/cqf/tooling/parameter/RefreshIGParameters.java @@ -25,4 +25,5 @@ public class RefreshIGParameters { public String libraryOutputPath; public String measureOutputPath; public Boolean verboseMessaging; + public String updatedVersion; } \ No newline at end of file diff --git a/tooling/src/main/java/org/opencds/cqf/tooling/processor/argument/RefreshIGArgumentProcessor.java b/tooling/src/main/java/org/opencds/cqf/tooling/processor/argument/RefreshIGArgumentProcessor.java index 4026769ab..8186b3ad9 100644 --- a/tooling/src/main/java/org/opencds/cqf/tooling/processor/argument/RefreshIGArgumentProcessor.java +++ b/tooling/src/main/java/org/opencds/cqf/tooling/processor/argument/RefreshIGArgumentProcessor.java @@ -16,7 +16,7 @@ public class RefreshIGArgumentProcessor { - public static final String[] OPERATION_OPTIONS = {"RefreshIG"}; + public static final String[] OPERATION_OPTIONS = {"RefreshIG", "NewRefreshIG"}; public static final String[] INI_OPTIONS = {"ini"}; public static final String[] ROOT_DIR_OPTIONS = {"root-dir", "rd"}; public static final String[] IG_PATH_OPTIONS = {"ip", "ig-path"}; @@ -28,6 +28,7 @@ public class RefreshIGArgumentProcessor { public static final String[] INCLUDE_TERMINOLOGY_OPTIONS = {"t", "include-terminology"}; public static final String[] INCLUDE_PATIENT_SCENARIOS_OPTIONS = {"p", "include-patients"}; public static final String[] VERSIONED_OPTIONS = {"v", "versioned"}; + public static final String[] UPDATED_VERSION_OPTIONS = {"uv", "updated-version"}; public static final String[] FHIR_URI_OPTIONS = {"fs", "fhir-uri"}; public static final String[] MEASURE_TO_REFRESH_PATH = {"mtrp", "measure-to-refresh-path"}; public static final String[] RESOURCE_PATH_OPTIONS = {"rp", "resourcepath"}; @@ -45,6 +46,7 @@ public OptionParser build() { OptionSpecBuilder iniBuilder = parser.acceptsAll(asList(INI_OPTIONS), "Path to ig ini file"); OptionSpecBuilder rootDirBuilder = parser.acceptsAll(asList(ROOT_DIR_OPTIONS), "Root directory of the ig"); + OptionSpecBuilder updatedVersionBuilder = parser.acceptsAll(asList(UPDATED_VERSION_OPTIONS), "Version for the new libraries"); OptionSpecBuilder igPathBuilder = parser.acceptsAll(asList(IG_PATH_OPTIONS),"Path to the IG, relative to the root directory"); OptionSpecBuilder resourcePathBuilder = parser.acceptsAll(asList(RESOURCE_PATH_OPTIONS),"Use multiple times to define multiple resource directories, relative to the root directory."); OptionSpecBuilder libraryPathBuilder = parser.acceptsAll(asList(LIBRARY_PATH_OPTIONS), "Provide a single path, relative to the root directory, for library resources. The path will be added to the resource directories available to the refresh processing."); @@ -58,6 +60,7 @@ public OptionParser build() { OptionSpecBuilder shouldVerboseMessaging = parser.acceptsAll(asList(SHOULD_APPLY_SOFTWARE_SYSTEM_STAMP_OPTIONS),"Indicates that a complete list of errors during library, measure, and test case refresh are included upon failure."); OptionSpec ini = iniBuilder.withRequiredArg().describedAs("Path to the IG ini file"); + OptionSpec updatedVersion = updatedVersionBuilder.withOptionalArg().describedAs("Updated version of the IG"); OptionSpec rootDir = rootDirBuilder.withOptionalArg().describedAs("Root directory of the IG"); OptionSpec igPath = igPathBuilder.withRequiredArg().describedAs("Path to the IG, relative to the root directory"); OptionSpec resourcePath = resourcePathBuilder.withOptionalArg().describedAs("directory of resources"); @@ -124,6 +127,11 @@ public RefreshIGParameters parseAndConvert(String[] args) { String fhirUri = (String)options.valueOf(FHIR_URI_OPTIONS[0]); String measureToRefreshPath = (String)options.valueOf(MEASURE_TO_REFRESH_PATH[0]); + String updatedVersion = (String)options.valueOf(UPDATED_VERSION_OPTIONS[0]); + if(updatedVersion == null) { + updatedVersion = ""; + } + String libraryOutputPath = (String)options.valueOf(LIBRARY_OUTPUT_PATH_OPTIONS[0]); if (libraryOutputPath == null) { libraryOutputPath = ""; @@ -178,6 +186,7 @@ public RefreshIGParameters parseAndConvert(String[] args) { ip.measureToRefreshPath = measureToRefreshPath; ip.libraryOutputPath = libraryOutputPath; ip.measureOutputPath = measureOutputPath; + ip.updatedVersion = updatedVersion; ip.verboseMessaging = verboseMessaging; return ip; } diff --git a/tooling/src/test/java/org/opencds/cqf/tooling/RefreshTest.java b/tooling/src/test/java/org/opencds/cqf/tooling/RefreshTest.java index c2e76e95d..75aed0cd1 100644 --- a/tooling/src/test/java/org/opencds/cqf/tooling/RefreshTest.java +++ b/tooling/src/test/java/org/opencds/cqf/tooling/RefreshTest.java @@ -78,8 +78,7 @@ protected void copyResourcesToTargetDir(String targetDirectory, String resourceD File outputDirectory = new File(targetDirectory); outputDirectory.mkdirs(); URL url = RefreshTest.class.getResource(resourceDirectoryPath); - String path = url.getPath(); - File resourceDirectory = new File(path); + File resourceDirectory = FileUtils.toFile(url); FileUtils.copyDirectory(resourceDirectory, outputDirectory); } diff --git a/tooling/src/test/java/org/opencds/cqf/tooling/operation/RefreshIGOperationTest.java b/tooling/src/test/java/org/opencds/cqf/tooling/operation/RefreshIGOperationTest.java index 8a2a795ca..6c861325b 100644 --- a/tooling/src/test/java/org/opencds/cqf/tooling/operation/RefreshIGOperationTest.java +++ b/tooling/src/test/java/org/opencds/cqf/tooling/operation/RefreshIGOperationTest.java @@ -25,7 +25,6 @@ import org.opencds.cqf.tooling.RefreshTest; import org.opencds.cqf.tooling.parameter.RefreshIGParameters; import org.opencds.cqf.tooling.processor.IGProcessor; -import org.opencds.cqf.tooling.processor.TestCaseProcessor; import org.opencds.cqf.tooling.processor.argument.RefreshIGArgumentProcessor; import org.opencds.cqf.tooling.utilities.IOUtils; import org.opencds.cqf.tooling.utilities.ResourceUtils; @@ -47,7 +46,6 @@ import static org.testng.Assert.*; import org.hl7.fhir.r4.model.Group; -import org.hl7.fhir.r4.model.Reference; public class RefreshIGOperationTest extends RefreshTest { protected final Logger logger = LoggerFactory.getLogger(this.getClass()); public RefreshIGOperationTest() { @@ -64,7 +62,7 @@ public RefreshIGOperationTest() { private final String LIB_TYPE = "Library"; private final String MEASURE_TYPE = "Measure"; - private final String INI_LOC = "target" + separator + "refreshIG" + separator + "ig.ini"; + private final String INI_LOC = Path.of("target","refreshIG","ig.ini").toString(); // Store the original standard out before changing it. @@ -147,7 +145,7 @@ public void testBundledFiles() throws IOException { wireMockServer.stop(); } - // determine fhireContext for measure lookup + // determine fhirContext for measure lookup FhirContext fhirContext = IGProcessor.getIgFhirContext(getFhirVersion(ini)); // get list of measures resulting from execution diff --git a/tooling/src/test/resources/NewRefreshIG/ig.ini b/tooling/src/test/resources/NewRefreshIG/ig.ini new file mode 100644 index 000000000..e6609c8ee --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/ig.ini @@ -0,0 +1,4 @@ +[IG] +ig = input/cqf-us.xml +template = cqf.fhir.template +usage-stats-opt-out = false diff --git a/tooling/src/test/resources/NewRefreshIG/input/cqf-us.xml b/tooling/src/test/resources/NewRefreshIG/input/cqf-us.xml new file mode 100644 index 000000000..cdf3030a9 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cqf-us.xml @@ -0,0 +1,134 @@ + + + + + + + + + <status value="draft"/> + <experimental value="false"/> + <publisher value="Clinical Quality Framework"/> + <contact> + <telecom> + <system value="url"/> + <value value="http://github.com/cqframework"/> + </telecom> + </contact> + <description value="This implementation guide contains common FHIR assets for use in US-based CQFramework content IGs, including the USCore-ModelInfo and USCommon libraries."/> + <jurisdiction> + <coding> + <system value="http://unstats.un.org/unsd/methods/m49/m49.htm"/> + <code value="840"/> + <display value="USA"/> + </coding> + </jurisdiction> + <packageId value="fhir.cqf.us.common"/> + <license value="CC0-1.0"/> + <fhirVersion value="4.0.1"/> + <!-- Do not declare this dependency, since we would like to use this IG to fix + the reference problems in CPG as well... + <dependsOn id="cpg"> + <uri value="http://hl7.org/fhir/uv/cpg/ImplementationGuide/hl7.fhir.uv.cpg"/> + <packageId value="hl7.fhir.uv.cpg"/> + <version value="1.0.0"/> + </dependsOn>--> + <dependsOn id="cqf"> + <uri value="http://fhir.org/guides/cqf/common/ImplementationGuide/fhir.cqf.common"/> + <packageId value="fhir.cqf.common"/> + <version value="4.0.1"/> + </dependsOn> + <dependsOn id="uscore"> + <uri value="http://hl7.org/fhir/us/core/ImplementationGuide/hl7.fhir.us.core"/> + <packageId value="hl7.fhir.us.core"/> + <version value="3.1.1"/> + </dependsOn> + <definition> + <page> + <!-- The root will always be toc.html - the template will force it if you don't do it --> + <nameUrl value="toc.html"/> + <title value="Table of Contents"/> + <generation value="html"/> + <page> + <nameUrl value="index.html"/> + <title value="Home"/> + <generation value="html"/> + </page> + <page> + <nameUrl value="downloads.html"/> + <title value="Downloads"/> + <generation value="html"/> + </page> + <page> + <nameUrl value="license.html"/> + <title value="License"/> + <generation value="markdown"/> + </page> + </page> + <!-- copyright year is a mandatory parameter --> + <parameter> + <code value="copyrightyear"/> + <value value="2019+"/> + </parameter> + <!-- releaselabel should be the ballot status for HL7-published IGs. --> + <parameter> + <code value="releaselabel"/> + <value value="CI Build"/> + </parameter> + <parameter> + <code value="find-other-resources"/> + <value value="true"/> + </parameter> + <!-- This parameter indicates to the publisher that it should translate and package CQL libraries. See the example library resources for more --> + <!-- Disabling because the publisher tooling does not know how to deal with FHIRHelpers and FHIR-ModelInfo in this IG --> + <parameter> + <code value="path-binary"/> + <value value="input/cql"/> + </parameter> +<!-- <parameter>--> +<!-- <code value="path-resource"/>--> +<!-- <value value="input/resources/device"/>--> +<!-- </parameter>--> + <parameter> + <code value="path-resource"/> + <value value="input/resources/library"/> + </parameter> +<!-- <parameter>--> +<!-- <code value="path-resource"/>--> +<!-- <value value="input/resources/questionnaire"/>--> +<!-- </parameter>--> +<!-- <parameter>--> +<!-- <code value="path-liquid"/>--> +<!-- <value value="templates\liquid"/>--> +<!-- </parameter>--> +<!-- <parameter>--> +<!-- <code value="path-suppressed-warnings"/>--> +<!-- <value value="input/ignoreWarnings.txt"/>--> +<!-- </parameter>--> +<!-- <!– Allow the domain CPG. This does prevent a few of the errors,--> +<!-- but the canonical URLs for extensions and profiles from this domain still result in errors... –>--> +<!-- <parameter>--> +<!-- <code value="extension-domain"/>--> +<!-- <value value="http://hl7.org/fhir/uv/cpg"/>--> +<!-- </parameter>--> +<!-- Uncomment one or more of these if you want to limit which syntaxes are supported or want to disable the display of mappings + <parameter> + <code value="excludexml"/> + <value value="true"/> + </parameter> + <parameter> + <code value="excludejson"/> + <value value="true"/> + </parameter> + <parameter> + <code value="excludettl"/> + <value value="true"/> + </parameter> + <parameter> + <code value="excludemap"/> + <value value="true"/> + </parameter>--> + </definition> +</ImplementationGuide> diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/CumulativeMedicationDuration.cql b/tooling/src/test/resources/NewRefreshIG/input/cql/CumulativeMedicationDuration.cql new file mode 100644 index 000000000..7f0cbd98a --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/CumulativeMedicationDuration.cql @@ -0,0 +1,596 @@ +/* +@description: This library provides cumulative medication duration calculation +logic for use with FHIR medication prescription, administration, and dispensing +resources. The logic here follows the guidance provided as part of the 5.6 +version of Quality Data Model. +@comment: Note that the logic here assumes single-instruction dosing information. +Split-dosing, tapering, and other more complex dosing instructions are not handled. +@update: +v0.2.000 +Fixed Quantity handling in duration calculations +Fixed authorDatetime null handling +Changed to provide Date-level calculation, rather than DateTime +v2.0.000 +Updated as part of 2022 AU refresh +Refactored to use QICoreCommon +v2.0.001 +Fixed invalid unit error evaluating RolloutIntervals +Fixed RolloutIntervals incorrectly eliminating duplicates +v3.1.000 +updated to reflect changes from AU2022 QDM library changes _JKR +*/ +library CumulativeMedicationDuration version '3.1.000' + +using USCore version '3.1.1' +// NOTE: Including FHIR to handle MedicationDispense and MedicationAdministration (not in USCore 3.1.1) +// TODO: Remove this reference once USCore supports MedicationDispense and MedicationAdministration +using FHIR version '4.0.1' + +// NOTE: Removed in favor of USCore version '3.1.1' +//using QICore version '4.1.1' + +// NOTE: Updated to 4.0.1 for now to simplify dependencies +// NOTE: include FHIRHelpers version '4.2.000' +include fhir.cqf.common.FHIRHelpers version '4.0.1' + +// NOTE: Removed in favor of USCoreCommon +//include QICoreCommon version '1.3.000' +include USCoreCommon version '0.1.0' + +// These code systems are not known to the MAT environment yet, request to have them added submitted +codesystem "V3TimingEvent": 'http://terminology.hl7.org/CodeSystem/v3-TimingEvent' +codesystem "EventTiming": 'http://hl7.org/fhir/event-timing' + +code "HS": 'HS' from "V3TimingEvent" // event occurs [offset] before the hour of sleep (or trying to) +code "WAKE": 'WAKE' from "V3TimingEvent" // event occurs [offset] after waking +code "C": 'C' from "V3TimingEvent" // event occurs at a meal (from the Latin cibus) +code "CM": 'CM' from "V3TimingEvent" // event occurs at breakfast (from the Latin cibus matutinus) +code "CD": 'CD' from "V3TimingEvent" // event occurs at lunch (from the Latin cibus diurnus) +code "CV": 'CV' from "V3TimingEvent" // event occurs at dinner (from the Latin ante cibus vespertinus) +code "AC": 'AC' from "V3TimingEvent" // event occurs [offset] before a meal (from the Latin ante cibus) +code "ACM": 'ACM' from "V3TimingEvent" // event occurs [offset] before breakfast (from the Latin ante cibus matutinus) +code "ACD": 'ACD' from "V3TimingEvent" // event occurs [offset] before lunch (from the Latin ante cibus diurnus) +code "ACV": 'ACV' from "V3TimingEvent" // event occurs [offset] before dinner (from the Latin ante cibus vespertinus) +code "PC": 'PC' from "V3TimingEvent" // event occurs [offset] after a meal (from the Latin post cibus) +code "PCM": 'PCM' from "V3TimingEvent" // event occurs [offset] after breakfast (from the Latin post cibus matutinus) +code "PCD": 'PCD' from "V3TimingEvent" // event occurs [offset] after lunch (from the Latin post cibus diurnus) +code "PCV": 'PCV' from "V3TimingEvent" // event occurs [offset] after dinner (from the Latin post cibus vespertinus) + +code "MORN": 'MORN' from EventTiming // Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation. +code "MORN.early": 'MORN.early' from EventTiming // Early Morning Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation. +code "MORN.late": 'MORN.late' from EventTiming // Late Morning Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation. +code "NOON": 'NOON' from EventTiming // Noon Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation. +code "AFT": 'AFT' from EventTiming // Afternoon Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation. +code "AFT.early": 'AFT.early' from EventTiming // Early Afternoon Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation. +code "AFT.late": 'AFT.late' from EventTiming // Late Afternoon Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation. +code "EVE": 'EVE' from EventTiming // Evening Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation. +code "EVE.early": 'EVE.early' from EventTiming // Early Evening Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation. +code "EVE.late": 'EVE.late' from EventTiming // Late Evening Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation. +code "NIGHT": 'NIGHT' from EventTiming // Night Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation. +code "PHS": 'PHS' from EventTiming // After Sleep Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation. + +code "Every eight hours (qualifier value)": '307469008' from USCoreCommon."SNOMEDCT" display 'Every eight hours (qualifier value)' +code "Every eight to twelve hours (qualifier value)": '396140003' from USCoreCommon."SNOMEDCT" display 'Every eight to twelve hours (qualifier value)' +code "Every forty eight hours (qualifier value)": '396131002' from USCoreCommon."SNOMEDCT" display 'Every forty eight hours (qualifier value)' +code "Every forty hours (qualifier value)": '396130001' from USCoreCommon."SNOMEDCT" display 'Every forty hours (qualifier value)' +code "Every four hours (qualifier value)": '225756002' from USCoreCommon."SNOMEDCT" display 'Every four hours (qualifier value)' +code "Every seventy two hours (qualifier value)": '396143001' from USCoreCommon."SNOMEDCT" display 'Every seventy two hours (qualifier value)' +code "Every six hours (qualifier value)": '307468000' from USCoreCommon."SNOMEDCT" display 'Every six hours (qualifier value)' +code "Every six to eight hours (qualifier value)": '396139000' from USCoreCommon."SNOMEDCT" display 'Every six to eight hours (qualifier value)' +code "Every thirty six hours (qualifier value)": '396126004' from USCoreCommon."SNOMEDCT" display 'Every thirty six hours (qualifier value)' +code "Every three to four hours (qualifier value)": '225754004' from USCoreCommon."SNOMEDCT" display 'Every three to four hours (qualifier value)' +code "Every three to six hours (qualifier value)": '396127008' from USCoreCommon."SNOMEDCT" display 'Every three to six hours (qualifier value)' +code "Every twelve hours (qualifier value)": '307470009' from USCoreCommon."SNOMEDCT" display 'Every twelve hours (qualifier value)' +code "Every twenty four hours (qualifier value)": '396125000' from USCoreCommon."SNOMEDCT" display 'Every twenty four hours (qualifier value)' +code "Every two to four hours (qualifier value)": '225752000' from USCoreCommon."SNOMEDCT" display 'Every two to four hours (qualifier value)' +code "Four times daily (qualifier value)": '307439001' from USCoreCommon."SNOMEDCT" display 'Four times daily (qualifier value)' +code "Once daily (qualifier value)": '229797004' from USCoreCommon."SNOMEDCT" display 'Once daily (qualifier value)' +code "One to four times a day (qualifier value)": '396109005' from USCoreCommon."SNOMEDCT" display 'One to four times a day (qualifier value)' +code "One to three times a day (qualifier value)": '396108002' from USCoreCommon."SNOMEDCT" display 'One to three times a day (qualifier value)' +code "One to two times a day (qualifier value)": '396107007' from USCoreCommon."SNOMEDCT" display 'One to two times a day (qualifier value)' +code "Three times daily (qualifier value)": '229798009' from USCoreCommon."SNOMEDCT" display 'Three times daily (qualifier value)' +code "Twice a day (qualifier value)": '229799001' from USCoreCommon."SNOMEDCT" display 'Twice a day (qualifier value)' +code "Two to four times a day (qualifier value)": '396111001' from USCoreCommon."SNOMEDCT" display 'Two to four times a day (qualifier value)' + +parameter ErrorLevel String default 'Warning' + +context Patient + +/* + Goal is to get to number of days + Two broad approaches to the calculation: + 1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered + 2) Based on relevant period, determine a covered interval and calculate the length of that interval in days + +This topic covers several use cases and illustrates how to calculate Cumulative +Medication Duration for each type of medication resource using the supply and +frequency approach. +*/ + +/* + For the first approach, we need to get from frequency to a frequency/day + So we define ToDaily +*/ + +/* + Calculates daily frequency given frequency within a period +*/ +define function ToDaily(frequency System.Integer, period System.Quantity): + case period.unit + when 'h' then frequency * (24.0 / period.value) + when 'min' then frequency * (24.0 / period.value) * 60 + when 's' then frequency * (24.0 / period.value) * 60 * 60 + when 'd' then frequency * (24.0 / period.value) / 24 + when 'wk' then frequency * (24.0 / period.value) / (24 * 7) + when 'mo' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */ + when 'a' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */ + when 'hour' then frequency * (24.0 / period.value) + when 'minute' then frequency * (24.0 / period.value) * 60 + when 'second' then frequency * (24.0 / period.value) * 60 * 60 + when 'day' then frequency * (24.0 / period.value) / 24 + when 'week' then frequency * (24.0 / period.value) / (24 * 7) + when 'month' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */ + when 'year' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */ + when 'hours' then frequency * (24.0 / period.value) + when 'minutes' then frequency * (24.0 / period.value) * 60 + when 'seconds' then frequency * (24.0 / period.value) * 60 * 60 + when 'days' then frequency * (24.0 / period.value) / 24 + when 'weeks' then frequency * (24.0 / period.value) / (24 * 7) + when 'months' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */ + when 'years' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */ + else Message(null, true, 'CMDLogic.ToDaily.UnknownUnit', ErrorLevel, 'Unknown unit ' & period.unit) + end + +/* + Returns a daily frequency for the given code representation of frequency. + The function expects codes from the [EventTiming](http://hl7.org/fhir/codesystem-event-timing.html) or + [V3TimingEvent](http://hl7.org/fhir/v3/TimingEvent/cs.html) code systems. + // TODO: Determine whether or not we should use timing.code at all.... +*/ +define function ToDaily(frequency Code): + case + when frequency ~ "HS" then 1 // event occurs [offset] before the hour of sleep (or trying to) + when frequency ~ "WAKE" then 1 // event occurs [offset] after waking + when frequency ~ "C" then 3 // event occurs at a meal (from the Latin cibus) + when frequency ~ "CM" then 1 // event occurs at breakfast (from the Latin cibus matutinus) + when frequency ~ "CD" then 1 // event occurs at lunch (from the Latin cibus diurnus) + when frequency ~ "CV" then 1 // event occurs at dinner (from the Latin ante cibus vespertinus) + when frequency ~ "AC" then 3 // event occurs [offset] before a meal (from the Latin ante cibus) + when frequency ~ "ACM" then 1 // event occurs [offset] before breakfast (from the Latin ante cibus matutinus) + when frequency ~ "ACD" then 1 // event occurs [offset] before lunch (from the Latin ante cibus diurnus) + when frequency ~ "ACV" then 1 // event occurs [offset] before dinner (from the Latin ante cibus vespertinus) + when frequency ~ "PC" then 3 // event occurs [offset] after a meal (from the Latin post cibus) + when frequency ~ "PCM" then 1 // event occurs [offset] after breakfast (from the Latin post cibus matutinus) + when frequency ~ "PCD" then 1 // event occurs [offset] after lunch (from the Latin post cibus diurnus) + when frequency ~ "PCV" then 1 // event occurs [offset] after dinner (from the Latin post cibus vespertinus) + + when frequency ~ "MORN" then 1 // Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "MORN.early" then 1 // Early Morning Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "MORN.late" then 1 // Late Morning Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "NOON" then 1 // Noon Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "AFT" then 1 // Afternoon Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "AFT.early" then 1 // Early Afternoon Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "AFT.late" then 1 // Late Afternoon Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "EVE" then 1 // Evening Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "EVE.early" then 1 // Early Evening Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "EVE.late" then 1 // Late Evening Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "NIGHT" then 1 // Night Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation. + when frequency ~ "PHS" then 1 // After Sleep Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation. + + when frequency ~ "Once daily (qualifier value)" then 1.0 + when frequency ~ "Twice a day (qualifier value)" then 2.0 + when frequency ~ "Three times daily (qualifier value)" then 3.0 + when frequency ~ "Four times daily (qualifier value)" then 4.0 + when frequency ~ "Every twenty four hours (qualifier value)" then 1.0 + when frequency ~ "Every twelve hours (qualifier value)" then 2.0 + when frequency ~ "Every thirty six hours (qualifier value)" then 0.67 + when frequency ~ "Every eight hours (qualifier value)" then 3.0 + when frequency ~ "Every four hours (qualifier value)" then 6.0 + when frequency ~ "Every six hours (qualifier value)" then 4.0 + when frequency ~ "Every seventy two hours (qualifier value)" then 0.33 + when frequency ~ "Every forty eight hours (qualifier value)" then 0.5 + when frequency ~ "Every eight to twelve hours (qualifier value)" then 3.0 + when frequency ~ "Every six to eight hours (qualifier value)" then 4.0 + when frequency ~ "Every three to four hours (qualifier value)" then 8.0 + when frequency ~ "Every three to six hours (qualifier value)" then 8.0 + when frequency ~ "Every two to four hours (qualifier value)" then 12.0 + when frequency ~ "One to four times a day (qualifier value)" then 4.0 + when frequency ~ "One to three times a day (qualifier value)" then 3.0 + when frequency ~ "One to two times a day (qualifier value)" then 2.0 + when frequency ~ "Two to four times a day (qualifier value)" then 4.0 + + else Message(null, true, 'CMDLogic.ToDaily.UnknownFrequencyCode', ErrorLevel, 'Unknown frequency code ' & frequency.code) + end + +/* +Now that we have a ToDaily function, we can approach calculation of the +duration of medication for an order. First, consider the definitions +for each element: + +* 1 and only 1 dosageInstruction +* 1 and only 1 doseAndRate +* 1 timing with 1 repeat +* frequency, frequencyMax, defaulting to 1 +* period, periodUnit, defaulting to 1 'd' +* doseQuantity or doseRange +* timeOfDay + +* authoredOn: The date the prescription was written +* dispenseRequest.validityPeriod: Time period supply is authorized for +* dispenseRequest.quantity: amount of medication supplied per dispense +* dispenseRequest.numberOfRepeatsAllowed: number of refills authorized +* dispenseRequest.expectedSupplyDuration: number of days supply per dispense +* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat +* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat +* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat +* dosageInstruction.timing.repeat.count: number of times to repeat +* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat +* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period +* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period +* dosageInstruction.timing.repeat.period: event occurs frequency times per period +* dosageInstruction.timing.repeat.periodMax: upper limit of period +* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a) +* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*) +* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...) +* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD... +* dosageInstruction.asNeeded +* dosageInstruction.doseAndRate.doseQuantity +* dosageInstruction.doseAndRate.doseRange + +If expectedSupplyDuration is present, then the duration is + + expectedSupplyDuration * (1 + numberOfRepeatsAllowed) + +If expectedSupplyDuration is not present, then it must be calculated based on the quantity, dosage, and frequency: + + (quantity / (dosage * frequency)) * (1 + numberOfRepeatsAllowed) + + dosage: Coalesce(end of doseAndRate.doseRange, doseAndRate.doseQuantity) + frequency: Coalesce(frequencyMax, frequency) + period: Quantity(period, periodUnit) + +If expectedSupplyDuration is not present and cannot be calculated, and the boundsPeriod is present (and completely specified), we can use that directly + + dosage.timing.repeat.boundsPeriod + +This calculation results in a number of days, which can then be turned into a period by anchoring that to the +start of the validityPeriod or the authoredOn: + + Interval[earliestDispensable, earliestDispensable + expectedSupplyDuration - 1] + + earliestDispensable: Coalesce(start of validityPeriod, authoredOn) + +The following function illustrates this completely: +*/ + +/* +Calculates the Medication Period for a single MedicationRequest. +MedicationRequest instances provided to this function are expected +to conform to the [MMEMedicationRequest](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationrequest.html) +profile, which expects: +* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error +* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error +* 1 timing with 1 repeat, missing timing or repeat elements will result in a null +* frequency, frequencyMax, defaulting to 1 +* period, periodUnit, defaulting to 1 'd' +* timeOfDay +* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null +Note that MedicationRequest status is not considered by this calculation, as the +list of MedicationRequest instances provided to this function should already have +considered appropriate statuses, depending on the use case, typically `completed`. + +NOTE: Updated return to use "date from end of boundsPeriod" to ensure result is Interval<Date> +*/ +define function MedicationRequestPeriodTest(Request USCore."MedicationRequestProfile"): + Request R + let + dosage: singleton from R.dosageInstruction, + doseAndRate: singleton from dosage.doseAndRate, + timing: dosage.timing, + frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency), + period: Quantity(timing.repeat.period, timing.repeat.periodUnit), + doseRange: doseAndRate.dose, + doseQuantity: doseAndRate.dose, + dose: Coalesce(end of doseRange, doseQuantity), + dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0), + boundsPeriod: timing.repeat.bounds as Interval<DateTime>, + expectedDaysSupply: R.dispenseRequest.expectedSupplyDuration.value, + // TODO: this isn't working as expected, convert results in null + //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value, + daysSupply: (R.dispenseRequest.expectedSupplyDuration).value, + quantity: R.dispenseRequest.quantity, + refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0), + startDate: + Coalesce( + date from start of boundsPeriod, + date from R.authoredOn, + date from start of R.dispenseRequest.validityPeriod + ), + totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills) + return { dosage: dosage, doseAndRate: doseAndRate, timing: timing, frequency: frequency, period: period, + doseRange: doseRange, doseQuantity: doseQuantity, dose: dose, dosesPerDay: dosesPerDay, boundsPeriod: boundsPeriod, + expectedDaysSupply: expectedDaysSupply, daysSupply: daysSupply, quantity: quantity, refills: refills, startDate: startDate, totalDaysSupplied: totalDaysSupplied, + requestPeriod: if startDate is not null and totalDaysSupplied is not null then + Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ] + else if startDate is not null and boundsPeriod."high" is not null then + Interval[startDate, date from end of boundsPeriod] + else + null} + +define function MedicationRequestPeriod(Request USCore."MedicationRequestProfile"): + Request R + let + dosage: singleton from R.dosageInstruction, + doseAndRate: singleton from dosage.doseAndRate, + timing: dosage.timing, + frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency), + period: Quantity(timing.repeat.period, timing.repeat.periodUnit), + doseRange: doseAndRate.dose, + doseQuantity: doseAndRate.dose, + dose: Coalesce(end of doseRange, doseQuantity), + dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0), + boundsPeriod: timing.repeat.bounds as Interval<DateTime>, + // TODO: this isn't working as expected, convert results in null + //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value, + daysSupply: (R.dispenseRequest.expectedSupplyDuration).value, + quantity: R.dispenseRequest.quantity, + refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0), + startDate: + Coalesce( + date from start of boundsPeriod, + date from R.authoredOn, + date from start of R.dispenseRequest.validityPeriod + ), + totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills) + return + if startDate is not null and totalDaysSupplied is not null then + Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ] + else if startDate is not null and boundsPeriod."high" is not null then + Interval[startDate, date from end of boundsPeriod] + else + null + +/* +Next, consider the MedicationDispense case: + +* whenPrepared: When product was prepared +* whenHandedOver: When product was given out +* quantity: Amount dispensed +* daysSupply: Amount of medication expressed as a timing amount +* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat +* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat +* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat +* dosageInstruction.timing.repeat.count: number of times to repeat +* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat +* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period +* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period +* dosageInstruction.timing.repeat.period: event occurs frequency times per period +* dosageInstruction.timing.repeat.periodMax: upper limit of period +* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a) +* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*) +* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...) +* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD... +* dosageInstruction.asNeeded +* dosageInstruction.doseAndRate.doseQuantity +* dosageInstruction.doseAndRate.doseRange + +We have effectively the same elements, with the same meanings, with the exception that the +event is documenting a single dispense, and does not contain refill information. In addition, +multiple dispense events would typically be present, and those would all have to be considered +as part of an overall calculation. That will be considered when we combine results, but for +this function, we'll focus on calculating the duration of a single dispense. + +With a MedicationDispense, dosage information is expected to be the same as the related +MedicationRequest, so boundsPeriod would still cover the entire prescription (including refills) +and so cannot be used to calculate the interval covered by the dispense. + +If the daysSupply element is present, then the duration in days is simply + + daysSupply + +Note specifically that we are not considering refills, as those would be covered +by subsequent dispense records. + +If daysSupplied is not present, then daysSupplied must be calculated based on +the quantity, dosage, and frequency: + + (quantity / (dosage * frequency)) + +This calculation results in a number of days, which can then be turned into a +period by anchoring that to the startDate, as determined by the first available +value of the start of the boundsPeriod, whenHandedOver, and whenPrepared. + + Interval[startDate, startDate + totalDaysSupplied - 1 day] +*/ + +/* +Calculates Medication Period for a given MedicationDispense +MedicationDispense instances provided to this function are expected +to conform to the [TODO: MMEMedicationDispense](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationdispense.html) +profile, which expects: +* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error +* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error +* 1 timing with 1 repeat, missing timing or repeat elements will result in a null +* frequency, frequencyMax, defaulting to 1 +* period, periodUnit, defaulting to 1 'd' +* timeOfDay +* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null +* whenHandedOver or whenPrepared, if missing both whenHandedOver and whenPrepared will result in a null + +Note that MedicationDispense status is not considered by this calculation, as the +list of MedicationDispense instances provided to this function should already have +considered appropriate statuses, depending on the use case, typically `completed`, +especially since whenHandedOver would be expected to be present for a completed +MedicationDispense. + +Note also that the dosage information recorded in a dispense is expected to be a copy of the +dispense information from the related medication request. As such, the boundsPeriod would be expected +to cover the entire range, and should _not_ be used for timing of the event. + +There is also active discussion in the Pharmacy WG about what date should be used if whenPrepared/whenHandedOver is not present. +This may take the form of an "original creation date", but may also be a "status change date" for dispense events that are updating +status of an existing dispense. That discussion is ongoing, so until that is resolved, this logic will return +null if whenPrepared/whenHandedOver are not available. +*/ +define function MedicationDispensePeriod(Dispense "MedicationDispense"): + Dispense D + let + dosage: singleton from D.dosageInstruction, + doseAndRate: singleton from dosage.doseAndRate, + timing: dosage.timing, + frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency), + period: Quantity(timing.repeat.period, timing.repeat.periodUnit), + doseRange: doseAndRate.dose, + doseQuantity: doseAndRate.dose, + dose: Coalesce(end of doseRange, doseQuantity), + daysSupply: (convert D.daysSupply to days).value, + dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0), + startDate: + Coalesce( + date from D.whenHandedOver, + date from D.whenPrepared + ), + totalDaysSupplied: Coalesce(daysSupply, D.quantity.value / (dose.value * dosesPerDay)) + return + if startDate is not null and totalDaysSupplied is not null then + Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day')] + else + null + +/* +Returns the established therapeutic duration for a given medication. +This is likely measure specific, though could potentially be established for +any drug and distributed as a CodeSystem supplement. +Defaulting to 14 days here for illustration. +*/ +define function TherapeuticDuration(medication Concept): + 14 days + +/* +Next we consider MedicationAdministration. This data type is typically used to +capture specific administration, with the relevantPeriod capturing start and stop +time of the administration event: + +* effective[x]: Start and end time of administration + +However, when calculating cumulative medication duration, it is typically the +therapeutic period of the medication that should be considered. Currently neither +the Medication nor MedicationKnowledge resources provide this information, so +we model it here as a function that can potentially be implemented in a variety +of ways, including measure-specific values, as well as distribution as an RxNorm +code system supplement. + +However it is obtained, if therapeutic duration can be obtained, and the effective +period has a start, the result will be + + Interval[startDate, startDate + therapeuticDuration - 1 day] + +NOTE: Therapeutic duration needs to be established and until a way is implemented to +do that based on the medication, this logic is incomplete and should not be used. +*/ +define function MedicationAdministrationPeriod(Administration "MedicationAdministration"): + Administration M + let + therapeuticDuration: TherapeuticDuration(Administration.medication), + startDate: date from start of Administration.effective + return + if startDate is not null and therapeuticDuration is not null then + Interval[startDate, startDate + therapeuticDuration - 1] + else + null + +/* +Now that we have functions for determining the medication period for individual +prescriptions, administrations, and dispenses, we can combine those using +an overall cumulative medication duration calculation. + +There are two broad approaches to calculating cumulative duration, one that _collapses_ +overlapping intervals so that calculations are not duplicated, and one that _rolls out_ +overlapping intervals so that the durations are laid end-to-end. + +First, we define a function that simply calculates CumulativeDuration of a set of +intervals: + +NOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>> +*/ +define function CumulativeDuration(Intervals List<Interval<Date>>): + if Intervals is not null then ( Sum((collapse Intervals per day)X + return all(difference in days between start of X and + end of X + )+ 1 + ) + ) + else null + +/* +Next, we define a function that rolls out intervals: + +NOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>> +*/ +define function RolloutIntervals(intervals List<Interval<Date>>): + intervals I aggregate all R starting ( null as List<Interval<Date>>): R + union ( { I X + let S: Max({ + end of Last(R)+ 1 day, start of X } + ), + E: S + Quantity(Coalesce(duration in days of X, 0), 'day') + return Interval[S, E]} + ) + +/* +Then, we define a function that allows us to calculate based on the various medication +types: +*/ + +define function MedicationPeriod( + medication Choice<USCore."MedicationRequestProfile", + "MedicationDispense" + >): + case + when medication is USCore."MedicationRequestProfile" then MedicationRequestPeriod(medication) + when medication is MedicationDispense then MedicationDispensePeriod(medication) + else null + end + +/* +We can then use this function, combined with the MedicationDuration functions above +to calculate Cumulative Medication Duration: + +Generally speaking, we want to _roll out_ intervals from dispense and administration +events, and then collapse across that result and intervals from prescriptions. + +Note also that the separation of medications by type should already be done +by this stage as well. + +Calculations that combine dosages from different types of medications (such as Morphine Milligram Equivalent (MME) +or Average MME) require further consideration. +*/ + +define function CumulativeMedicationDuration( + Medications List<Choice<USCore."MedicationRequestProfile", + "MedicationDispense" + >>): + CumulativeDuration(( + Medications M + where M is MedicationRequest + return MedicationRequestPeriod(M) + ) + union ( + RolloutIntervals( + Medications M + where M is MedicationDispense + return MedicationDispensePeriod(M) + ) + ) + ) + + +/**********************************************************************/ +/* Functions in this region are copied from opioid-mme-r4 */ +/**********************************************************************/ + +define function Quantity(value Decimal, unit String): + if value is not null then + System.Quantity { value: value, unit: unit } + else + null diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/GMTPInitialExpressions.cql b/tooling/src/test/resources/NewRefreshIG/input/cql/GMTPInitialExpressions.cql new file mode 100644 index 000000000..b64fac705 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/GMTPInitialExpressions.cql @@ -0,0 +1,237 @@ +library GMTPInitialExpressions version '0.1.0' + +using USCore version '3.1.1' +using FHIR version '4.0.1' + +include fhir.cqf.common.FHIRHelpers version '4.0.1' +include USCoreCommon version '0.1.0' called UC +include USCoreElements version '0.1.0' called UCE + +codesystem "LOINC": 'http://loinc.org' +codesystem "Identifier Type": 'http://terminology.hl7.org/CodeSystem/v2-0203' +code "Member Number": 'MB' from "Identifier Type" + + +context Patient + +define "Humana ID": // Similar to Member ID from MBODA Initial expressions? + singleton from + ( + ( + ( + ([FHIR.Coverage] C + where EndsWith(C.beneficiary.reference, Patient.id)) + .identifier) I + return {value: I.value.value, type: I.type.coding.code} + ) valuesByTypes + where "Member Number".code in valuesByTypes.type + return valuesByTypes.value + ) + +define "Patient Name": + UCE."Name - First Middle(s) Last" + +define "Date of Birth": + Patient.birthDate + +define "Phone Number": + UC.Mobile(Patient.telecom).value + +// TODO: Error: Could not resolve data provider for package 'java.util'. +/* +define "Address": + (singleton from Patient.address).line +*/ + +define "Requesting Provider Practitioner"://assuming the requester is a practitioner + [PractitionerProfile] P + where EndsWith("Most Recent ServiceRequest".requester.reference.value, P.id) + +/*//if the requester is an Organization: +define "Requesting Provider Organization": + [OrganizationProfile] O + where EndsWith("Most Recent ServiceRequest".requester.reference.value, O.id) + */ + +define "Requesting Provider": + "Requesting Provider Practitioner" + + +define "Requesting Provider Name": + "Requesting Provider".name.family + +define "Requesting Provider Phone": + UC.Mobile("Requesting Provider".telecom).value +/* +define "Requesting Provider Address": + (singleton from "Requesting Provider".address).line +*/ +define "Requesting Provider NPI": + "Requesting Provider".identifier I + where I.system = 'http://hl7.org/fhir/sid/us-npi' + return I.value + +define "Requesting Provider Fax": + "Requesting Provider".telecom T + where T.system = 'fax' + return T.value + + +define "Servicing Provider"://assuming the servicing provider is a lab - (molecular/genetic testing) + singleton from ([OrganizationProfile] O + where EndsWith(First("Most Recent ServiceRequest".performer.reference.value), O.id)) + +define "Servicing Provider Name": + "Servicing Provider".name + +define "Servicing Provider Phone": + UC.Mobile("Servicing Provider".telecom).value + +// TODO: Error: Could not resolve data provider for package 'java.util'. +/* +define "Servicing Provider Address": + (singleton from "Servicing Provider".address).line +*/ +define "Servicing Provider NPI": + "Servicing Provider".identifier I + where I.system = 'http://hl7.org/fhir/sid/us-npi' + return I.value + +define "Servicing Provider Fax": + "Servicing Provider".telecom T + where T.system = 'fax' + return T.value + +define "Test Coverage": +[FHIR.Coverage] C +with "Most Recent ServiceRequest" SR such that EndsWith(First(SR.insurance.reference), C.id) + + +define "Billing Provider": + singleton from([OrganizationProfile] O + where EndsWith(First("Test Coverage".payor.reference.value), O.id)) + +define "Billing Provider Name": + "Billing Provider".name + +define "Billing Provider Phone": + UC.Mobile("Billing Provider".telecom).value + +// TODO: Error: Could not resolve data provider for package 'java.util'. +/* +define "Billing Provider Address": + (singleton from "Billing Provider".address).line +*/ +define "Billing Provider NPI": + "Billing Provider".identifier I + where I.system = 'http://hl7.org/fhir/sid/us-npi' + return I.value + +define "Billing Provider Fax": + "Billing Provider".telecom T + where T.system = 'fax' + return T.value + +define "All ServiceRequests": + [FHIR.ServiceRequest] + +define "Most Recent ServiceRequest": + UC.MostRecentSR("All ServiceRequests") + +define "Date of Service": + "Most Recent ServiceRequest".occurrence.value + +define "Requested Test": + "Most Recent ServiceRequest" SR + return SR.code + +define "Test ID": + "Requested Test".coding.code.value + +define "Test name": + "Requested Test".coding.display.value + +define "ALL ICD and CPT Test Codes": + "Test ICD Codes" union "Test CPT Codes" as List<FHIR.Coding> + +define "Test ICD Codes": + "Requested Test".coding C + where C.system.value = 'http://hl7.org/fhir/sid/icd-10-cm' + return C + +define "Test CPT Codes": + "Requested Test".coding C + where C.system.value = 'http://www.ama-assn.org/go/cpt' + return C + +define "Test Related Condition": + [FHIR.Condition] C + where EndsWith(First("Most Recent ServiceRequest".reasonReference.reference.value), C.id) + //.reasonReference changed to .reason in FHIR R5 + +define "Diagnosis Descriptions": + "Test Related Condition".code.coding.display.value + +define "Billing Provider different from Servicing Provider": + if "Billing Provider".id != "Servicing Provider".id then + 'Yes' + else + 'No' + +define "Clinical Trial Organization": + First([OrganizationProfile] O + with "Clinical Trial" T such that EndsWith(T.sponsor.reference, O.id)) //in FHIR R5 T.associatedParty instead of T.sponsor + +define "BillingProvider is Clinical Trial Organisation": + "Billing Provider" = "Clinical Trial Organization" + +//TODO does not get populated properly +define "Part of clinical trial": + if "Is Research Subject" and "BillingProvider is Clinical Trial Organisation" then + 'Yes' + else + 'No' + +define "Is Research Subject": + exists("Research Subject") + +define "Research Subject": + [FHIR.ResearchSubject] R + where EndsWith(R.individual.reference, Patient.id)//ResearchSubject.individual is from FHIR version v4.0.1 and has been replaced by R.subject in FHIR R5 + +define "All clinical Trials": +[FHIR.ResearchStudy] R + +define "Clinical Trial": + [FHIR.ResearchStudy] R + with "Research Subject" S such that EndsWith(S.study.reference, R.id) + with "Test Related Condition" C such that C.code in R.condition + +define "Clinical Trial ID": + "Clinical Trial".identifier C + where C.system = 'https://clinicaltrials.gov' + return C.value.value + + +define function "GetServiceRequestReasonCondition"(S ServiceRequest): + [FHIR.Condition] C + with "Most Recent ServiceRequest" SR such that EndsWith(First(SR.insurance.reference), C.id) + return C + + +define "Previous genetic testing for condition": + from "All ServiceRequests" S, + "Most Recent ServiceRequest" SR + where S.occurrence before SR.occurrence + and S.id != SR.id + and S.reasonReference = SR.reasonReference + return S.id.value + + +//define "Family history of genetic testing" +//too general to prefill? + +//define "Patient history" +//too general to prefill? + + diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/MBODAInitialExpressions.cql b/tooling/src/test/resources/NewRefreshIG/input/cql/MBODAInitialExpressions.cql new file mode 100644 index 000000000..66c23f86c --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/MBODAInitialExpressions.cql @@ -0,0 +1,248 @@ +library MBODAInitialExpressions version '0.1.0' + +using USCore version '3.1.1' +using FHIR version '4.0.1' + +include fhir.cqf.common.FHIRHelpers version '4.0.1' +include USCoreCommon version '0.1.0' called UC +include USCoreElements version '0.1.0' called UCE + +//CumulativeMedicationDuration was created as part of the US ECQM and CDC Opioid Guideline development +//http://fhir.org/guides/cdc/opioid-mme-r4 +include CumulativeMedicationDuration version '3.1.000' called CMD + +codesystem "LOINC": 'http://loinc.org' +codesystem "Identifier Type": 'http://terminology.hl7.org/CodeSystem/v2-0203' +code "Body surface area": '8277-6' from "LOINC" display 'Intensive care unit' +code "Member Number": 'MB' from "Identifier Type" + +context Patient + +define "Member ID": + singleton from + ( + ( + ( + ([FHIR.Coverage] C + where EndsWith(C.beneficiary.reference, Patient.id)) + .identifier) I + return {value: I.value.value, type: I.type.coding.code} + ) valuesByTypes + where "Member Number".code in valuesByTypes.type + return valuesByTypes.value + ) + + +define "Patient Name": + UCE."Name - First Middle(s) Last" + +define "Last Name": + UCE."Last Name" + +// TODO: Error: Could not resolve data provider for package 'java.util'. +// define "First Name": +// Patient.name.given.first() + +define "Date of Birth": + Patient.birthDate + +define "Medical Record Number": + singleton from + ( + (Patient.identifier I + return {value: I.value, type: I.type.codes.code} + ) valueByTypes + // TODO: create code for MR (medical record number) + where UC."MedicalRecordNumber".code in valueByTypes.type + return valueByTypes.value + ) + +define "Phone Number": + UC.Mobile(Patient.telecom).value + +define "Allergies": + UCE."Active Confirmed Allergies and Intolerances" A + return A.code + +// TODO: Error: Could not resolve data provider for package 'java.util'. +// define "Address": +// (singleton from Patient.address).line +define "Address": + { 'TODO: remove hard-coded address' } + +define "City": + Patient.address.city + +define "State": + Patient.address.state + +define "Zip": + Patient.address.postalCode + +define "Height": + convert( + UC.MostRecent( + UCE."All Body Height Measurements".resulted() + ).value + ) to '[in_i]' + +define "Height in [in_i]": + "Height".value + +define "Weight": + convert( + UC.MostRecent( + UCE."All Body Weight Measurements".resulted() + ).value + ) to '[lb_av]' + +define "Weight in [lb_av]": + "Weight".value + +define "Most Recent BSA": + convert( + UC.MostRecent( + ([FHIR.Observation: "Body surface area"] observation + where observation.status ~ UC."observation-final".code + or observation.status ~ UC."observation-amended".code + or observation.status ~ UC."observation-corrected".code + ) + ).value + ) to 'm2' + +define "BSA": + Coalesce("Most Recent BSA", "Calculated BSA - Mosteller") + +define "BSA in m2": + "BSA".value + +// Mosteller formula using lbs and inches +define "Calculated BSA - Mosteller": + CalculateBSA('Mosteller', "Height", "Weight") + //((("Weight"*"Height")/3131).value)^0.5 + +define "Height in cm": + convert("Height") to 'cm' + +define "Weight in kg": + convert("Weight") to 'kg' + +define "Calculated BSA - DuBois and DuBois": + CalculateBSA('DuBois and DuBois', "Height", "Weight") + +define function CalculateBSA(alg System.String, height System.Quantity, weight System.Quantity): + System.Quantity { value: + // Mosteller formula using lbs and inches + if (alg = 'Mosteller') then + ((((convert(height) to '[in_i]') * (convert(weight) to '[lb_av]'))/3131).value)^0.5 + + // DuBois and DuBois formula using cm and kg + // NOTE: never to be used for newborn calculation + else if (alg = 'DuBois and DuBois') then + 0.007184 * ((convert(height) to 'cm').value^0.725) * ((convert(weight) to 'kg').value^0.425) + + // No matching algorithm found + else null, + unit: 'm2' + } + +// QUESTION: do we want to use Patient.gender as a backup? If so we'll need a ConceptMap or translation +define "Birth Sex": + Patient.birthsex + +define "Diagnosis Codes": + UCE."All Conditions" C + return C.code + +define "Diagnosis Descriptions": + "Diagnosis Codes" ConceptItem + return Combine(((ConceptItem.codes) C return C.display), '|') + +define "Medication Requested": + UCE."All Medications" M + where EndsWith(("Most Recent Medication Request".medication as USCore.Reference).reference, M.id) + +define "Medication Name": + "Medication Requested" M + return M.code.display + +define "Code of Requested Drug": + "Medication Requested" M + return M.code + +define "Most Recent Medication Request": + UCE."Most Recent Medication Request" + +define "Medication Request References": + ("Most Recent Medication Request".medication as USCore.Reference).reference + +define "Most Recent Medication Request dosageInstruction": + // TODO: should this really be a singleton? + singleton from "Most Recent Medication Request".dosageInstruction + +define "Most Recent Medication Request dosageInstruction.doseAndRate": + // TODO: should this really be a singleton? + singleton from "Most Recent Medication Request dosageInstruction".doseAndRate + +define "Medication Dose": + "Most Recent Medication Request dosageInstruction.doseAndRate".dose + +define "Medication Route": + "Most Recent Medication Request dosageInstruction".route + +define "Medication Frequency value": + "Most Recent Medication Request dosageInstruction".timing.repeat.frequency + +define "Medication Frequency Period": + if (IsNull("Most Recent Medication Request dosageInstruction".timing.repeat.period)) then + null + else + System.Quantity { + value: "Most Recent Medication Request dosageInstruction".timing.repeat.period, + unit: "Most Recent Medication Request dosageInstruction".timing.repeat.periodUnit + } + +define "Medication Frequency": // '1x per 1d', '3x per 2wk', '1x per 1mo' + ToString("Medication Frequency value") + 'x' + + ' per ' + ToString("Medication Frequency Period".value) + + ' ' + "Medication Frequency Period".unit + +define "Quantity or Number of requested Visits": + "Most Recent Medication Request".dispenseRequest.quantity + +define "Prior Prescription": + "Most Recent Medication Request".priorPrescription + +define "New therapy": + IsNull("Prior Prescription") + +define "New therapy code": + if ("New therapy") then + System.Code { code: 'NewMedication', display: 'New Medication' } + else + System.Code { code: 'ContinuedTherapy', display: 'Continuation of therapy' } + +// MISSING: needs test data to validate +//Initial date of therapy does not return correct result if there have been more than 1 prior Prescriptions - logic needs to be adapted to that case +define "Initial date of therapy": + if not "New therapy" then + UCE."All Medication Requests" M + where EndsWith(("Most Recent Medication Request".priorPrescription as USCore.Reference).reference, M.id) + return M.authoredOn + else + null + +define "Medication Request Period": + CMD."MedicationRequestPeriod"("Most Recent Medication Request") + +define "Expected Therapy Length": + convert( + CMD.Quantity(days between start of "Medication Request Period" and end of "Medication Request Period", 'd') + ) to 'd' + +define "Anticipated/actual date of service": + start of "Medication Request Period" + +/* +//related Procedures - Procedure is not linked to medication request - not possible to find the related procedures +*/ \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/UPPARFInitialExpressions.cql b/tooling/src/test/resources/NewRefreshIG/input/cql/UPPARFInitialExpressions.cql new file mode 100644 index 000000000..7fadafdcf --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/UPPARFInitialExpressions.cql @@ -0,0 +1,225 @@ +library UPPARFInitialExpressions version '0.1.0' + +using USCore version '3.1.1' +using FHIR version '4.0.1' + +include fhir.cqf.common.FHIRHelpers version '4.0.1' +include USCoreCommon version '0.1.0' called UC +include USCoreElements version '0.1.0' called UCE + +codesystem "Identifier Type": 'http://terminology.hl7.org/CodeSystem/v2-0203' +codesystem "Verification Status": 'http://terminology.hl7.org/CodeSystem/condition-ver-status' +codesystem "Condition Clinical": 'http://terminology.hl7.org/CodeSystem/condition-clinical' +codesystem "ICD10": 'http://hl7.org/fhir/sid/icd-10-cm' +code "Member Number": 'MB' from "Identifier Type" +code "Subscriber Number": 'SN' from "Identifier Type" +code "Confirmed": 'confirmed' from "Verification Status" +code "Active": 'active' from "Condition Clinical" + + +context Patient + +define "Urgency": +"Most Recent Medication Request".priority P + return ( + if P != 'routine' then 'Urgent' + else 'Not Urgent' + ) + +//TODO: name could also be retrieved by MedicationRequest as a codeable concept if there is no reference +define "Most Recent Medication Name": + "Most Recent Medication" M + return M.code.display + +define "Is Opioid Treatment": +null //TBD + +//TODO: can we assume that with a previous prior authentication there also has been a prior prescription? +define "Is First Prior Authentication": +IsNull("Prior Prescription") + +//TODO: does the initial request date mean the exact same medication was requested before? +define "Initial Request Date": +if not "Is First Prior Authentication" then + singleton from ( + UCE."All Medication Requests" M + where EndsWith(("Most Recent Medication Request".priorPrescription as USCore.Reference).reference, M.id) + return M.authoredOn + ) + else + null + +define "Is First Request > 12 Months": +if IsNull("Initial Request Date") then null else +(months between "Initial Request Date" and Now() > 12) + +define "Patient Name": + UCE."Name - First Middle(s) Last" + +//TODO: is there a need to check for coverage period and order? also, do we need to check that the payor organization is the same as the source of the prior auth form? +define "Member ID": + singleton from + ( + ( + ( + ([FHIR.Coverage] C + where EndsWith(C.beneficiary.reference, Patient.id)) + .identifier) I + return {value: I.value.value, type: I.type.coding.code} + ) valuesByTypes + where "Member Number".code in valuesByTypes.type + return valuesByTypes.value + ) + +//TODO: is there a need to check for coverage period and order? also, do we need to check that the payor organization is the same as the source of the prior auth form? +define "Policy Number": +singleton from + ( + ( + ( + ([FHIR.Coverage] C + where EndsWith(C.beneficiary.reference, Patient.id)) + .identifier) I + return {value: I.value.value, type: I.type.coding.code} + ) valuesByTypes + where "Subscriber Number".code in valuesByTypes.type + return valuesByTypes.value + ) + +define "Date of Birth": + Patient.birthDate + +define "Address": + { 'TODO: remove hard-coded address' } + +define "Phone Number": + UC.Mobile(Patient.telecom).value + +define "Email Address": + Email(Patient.telecom).value + +define "Prescription Date": +"Most Recent Medication Request".authoredOn + +define "Prescriber Name": + First(Requester.name).family + //TODO: prefix, suffix and given do not work as expected. + +define "Prescriber Fax": + Fax(Requester.telecom).value + +define "Prescriber Phone": + UC.Mobile(Requester.telecom).value + +define "Prescriber Pager": + Pager(Requester.telecom).value + +define "Prescriber Address": +'TODO: remove hard coded address' + +define "Prescriber Contact": +'TODO: remove hard coded contact' +//TBD: would this be a work phone or more something like an address? + +define "Prescriber NPI": +First ( + "Requester".identifier I + where I.system = 'http://hl7.org.fhir/sid/us-npi' + ).value + +//TODO: what is DEA? +define "Prescriber DEA": + null + +define "Prescriber Tax ID": +First ( + "Requester".identifier I + where I.system = 'urn:oid:2.16.840.1.113883.4.4' + ).value + +define "Prescriber Specialty": +First(RequesterRole.specialty.codes).display + +define "Prescriber Email Address": +Email(Requester.telecom).value + +define "Request Type": +//TODO: is this logic correct? +if "Is First Prior Authentication" then +'New Request' else 'Reauthorization' + +define "ICD-10 Codes": + "All Patients Confirmed Active Diagnosis".code.codes C + where C.system = "ICD10".id + return C.code + +define "Diagnosis Descriptions": + "All Patients Confirmed Active Diagnosis".code.display + +define "Unit Volume of Named Drugs": +"Dosage Value as String" + "Dosage Unit" + +define "Dose": +"Dosage Value as String" + +define "Route": +First("Most Recent Medication Request".dosageInstruction).route.display + +define "Frequency": + ToString(First("Most Recent Medication Request".dosageInstruction).timing.repeat.frequency) + ' times per ' + + ToString(First("Most Recent Medication Request".dosageInstruction).timing.repeat.period) + + First("Most Recent Medication Request".dosageInstruction).timing.repeat.periodUnit + +define "Refills": +"Most Recent Medication Request".dispenseRequest.numberOfRepeatsAllowed + +define "Today": +Today() + +define "Dosage Value as String": + ToString(("Most Recent Medication Request".dosageInstruction.doseAndRate[0].dose as System.Quantity).value) + +define "Dosage Unit": + ("Most Recent Medication Request".dosageInstruction.doseAndRate[0].dose as System.Quantity).unit + +//helper definitions +//TODO: medications are not necessarily a reference but could also be represented by a codeeable concept +define "Most Recent Medication": +singleton from ( + UCE."All Medications" M + where EndsWith((UCE."Most Recent Medication Request".medication as USCore.Reference).reference, M.id)) + +define "Most Recent Medication Request": + UCE."Most Recent Medication Request" + +define "Prior Prescription": + "Most Recent Medication Request".priorPrescription + +define "All Patients Confirmed Active Diagnosis": +[USCore.Condition] C + where EndsWith(C.subject.reference, Patient.id) + and "Confirmed" in C.verificationStatus.codes + and "Active" in C.clinicalStatus.codes + +//TBD: is this better as part of us common? +define function Email(contactPoints List<USCore.ContactPoint>): + singleton from (contactPoints P where P.system = 'email') + + //TBD: is this better as part of us common? +define function Fax(contactPoints List<USCore.ContactPoint>): + singleton from (contactPoints P where P.system = 'fax') + + //TBD: is this better as part of us common? +define function Pager(contactPoints List<USCore.ContactPoint>): + singleton from (contactPoints P where P.system = 'pager') + + define "Requester": +singleton from ( +[USCore.PractitionerProfile] P + where EndsWith("Most Recent Medication Request".requester.reference, P.id)) + +define "RequesterRole": +singleton from ( +[USCore.PractitionerRoleProfile] R + where EndsWith(R.practitioner.reference, "Requester".id)) + diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreCommon.cql b/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreCommon.cql new file mode 100644 index 000000000..95b1b59d2 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreCommon.cql @@ -0,0 +1,628 @@ +/* +@author: Bryn Rhodes +@description: This library defines functions to expose extensions defined +in QICore as fluent functions in CQL, as well as common terminology and functions +used in writing CQL with FHIR and QICore profiles. +*/ +library USCoreCommon version '0.1.0' + +using USCore version '3.1.1' +using FHIR version '4.0.1' + +include fhir.cqf.common.FHIRHelpers version '4.0.1' + +codesystem "LOINC": 'http://loinc.org' +codesystem "SNOMEDCT": 'http://snomed.info/sct' +codesystem "CVX": 'http://hl7.org/fhir/sid/cvx' +codesystem "ActCode": 'http://terminology.hl7.org/CodeSystem/v3-ActCode' +codesystem "RoleCode": 'http://terminology.hl7.org/CodeSystem/v3-RoleCode' +codesystem "Diagnosis Role": 'http://terminology.hl7.org/CodeSystem/diagnosis-role' +codesystem "RequestIntent": 'http://hl7.org/fhir/request-intent' +codesystem "MedicationRequestCategory": 'http://terminology.hl7.org/CodeSystem/medicationrequest-category' +codesystem "ConditionClinicalStatusCodes": 'http://terminology.hl7.org/CodeSystem/condition-clinical' +codesystem "ConditionVerificationStatusCodes": 'http://terminology.hl7.org/CodeSystem/condition-ver-status' +codesystem "AllergyIntoleranceClinicalStatusCodes": 'http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical' +codesystem "AllergyIntoleranceVerificationStatusCodes": 'http://terminology.hl7.org/CodeSystem/allergyintolerance-verification' +codesystem "ObservationCategoryCodes": 'http://terminology.hl7.org/CodeSystem/observation-category' +codesystem "USCoreObservationCategory": 'http://hl7.org/fhir/us/core/CodeSystem/us-core-observation-category' +codesystem "ObservationStatusCodes": 'http://hl7.org/fhir/observation-status' +codesystem "ConditionCategory": 'http://terminology.hl7.org/CodeSystem/condition-category' +codesystem "USCoreConditionCategory": 'http://hl7.org/fhir/us/core/CodeSystem/condition-category' +codesystem "CDC Race and Ethnicity Codes": 'urn:oid:2.16.840.1.113883.6.238' +codesystem "CommunicationCategoryCodeSystem": 'http://terminology.hl7.org/CodeSystem/communication-category' +codesystem "IdentifierType": 'http://terminology.hl7.org/CodeSystem/v2-0203' + +code "MedicalRecordNumber": 'MR' from "IdentifierType" display 'Medical record number' + +code "Birthdate": '21112-8' from "LOINC" display 'Birth date' +code "Dead": '419099009' from "SNOMEDCT" display 'Dead' +code "ER": 'ER' from "RoleCode" display 'Emergency room' +code "ICU": 'ICU' from "RoleCode" display 'Intensive care unit' +code "Billing": 'billing' from "Diagnosis Role" display 'Billing' + +// Encounter Class Codes +code "ambulatory": 'AMB' from ActCode display 'ambulatory' +code "emergency": 'EMER' from ActCode display 'emergency' +code "field": 'FLD' from ActCode display 'field' +code "home health": 'HH' from ActCode display 'home health' +code "inpatient encounter": 'IMP' from ActCode display 'inpatient encounter' +code "inpatient acute": 'ACUTE' from ActCode display 'inpatient acute' +code "inpatient non-acute": 'NONAC' from ActCode display 'inpatient non-acute' +code "observation encounter": 'OBSENC' from ActCode display 'observation encounter' +code "pre-admission": 'PRENC' from ActCode display 'pre-admission' +code "short stay": 'SS' from ActCode display 'short stay' +code "virtual": 'VR' from ActCode display 'VR' + +// Condition Category Codes +code "problem-list-item": 'problem-list-item' from "ConditionCategory" display 'Problem List Item' +code "encounter-diagnosis": 'encounter-diagnosis' from "ConditionCategory" display 'Encounter Diagnosis' +code "health-concern": 'health-concern' from "USCoreConditionCategory" display 'Health Concern' + +// Condition Clinical Status Codes - Consider value sets for these +code "active": 'active' from "ConditionClinicalStatusCodes" +code "recurrence": 'recurrence' from "ConditionClinicalStatusCodes" +code "relapse": 'relapse' from "ConditionClinicalStatusCodes" +code "inactive": 'inactive' from "ConditionClinicalStatusCodes" +code "remission": 'remission' from "ConditionClinicalStatusCodes" +code "resolved": 'resolved' from "ConditionClinicalStatusCodes" + +// Condition Verification Status Codes - Consider value sets for these +code "unconfirmed": 'unconfirmed' from ConditionVerificationStatusCodes +code "provisional": 'provisional' from ConditionVerificationStatusCodes +code "differential": 'differential' from ConditionVerificationStatusCodes +code "confirmed": 'confirmed' from ConditionVerificationStatusCodes +code "refuted": 'refuted' from ConditionVerificationStatusCodes +code "entered-in-error": 'entered-in-error' from ConditionVerificationStatusCodes + +code "allergy-active": 'active' from "AllergyIntoleranceClinicalStatusCodes" +code "allergy-inactive": 'inactive' from "AllergyIntoleranceClinicalStatusCodes" +code "allergy-resolved": 'resolved' from "AllergyIntoleranceClinicalStatusCodes" + +// Allergy/Intolerance Verification Status Codes - Consider value sets for these +code "allergy-unconfirmed": 'unconfirmed' from AllergyIntoleranceVerificationStatusCodes +code "allergy-confirmed": 'confirmed' from AllergyIntoleranceVerificationStatusCodes +code "allergy-refuted": 'refuted' from AllergyIntoleranceVerificationStatusCodes + +// MedicationRequest Category Codes +code "Inpatient": 'inpatient' from "MedicationRequestCategory" display 'Inpatient' +code "Outpatient": 'outpatient' from "MedicationRequestCategory" display 'Outpatient' +code "Community": 'community' from "MedicationRequestCategory" display 'Community' +code "Discharge": 'discharge' from "MedicationRequestCategory" display 'Discharge' + +// Diagnosis Role Codes +code "AD": 'AD' from "Diagnosis Role" display 'Admission diagnosis' +code "DD": 'DD' from "Diagnosis Role" display 'Discharge diagnosis' +code "CC": 'CC' from "Diagnosis Role" display 'Chief complaint' +code "CM": 'CM' from "Diagnosis Role" display 'Comorbidity diagnosis' +code "pre-op": 'pre-op' from "Diagnosis Role" display 'pre-op diagnosis' +code "post-op": 'post-op' from "Diagnosis Role" display 'post-op diagnosis' +code "billing": 'billing' from "Diagnosis Role" display 'billing diagnosis' + +// Observation Category Codes +code "social-history": 'social-history' from "ObservationCategoryCodes" display 'Social History' +code "vital-signs": 'vital-signs' from "ObservationCategoryCodes" display 'Vital Signs' +code "imaging": 'imaging' from "ObservationCategoryCodes" display 'Imaging' +code "laboratory": 'laboratory' from "ObservationCategoryCodes" display 'Laboratory' +code "procedure": 'procedure' from "ObservationCategoryCodes" display 'Procedure' +code "survey": 'survey' from "ObservationCategoryCodes" display 'Survey' +code "exam": 'exam' from "ObservationCategoryCodes" display 'Exam' +code "therapy": 'therapy' from "ObservationCategoryCodes" display 'Therapy' +code "activity": 'activity' from "ObservationCategoryCodes" display 'Activity' +code "clinical-test": 'clinical-test' from "USCoreObservationCategory" display 'Clinical Test' + +// Observation Status Codes +code "observation-registered": 'registered' from "ObservationStatusCodes" display 'Registered' +code "observation-preliminary": 'preliminary' from "ObservationStatusCodes" display 'Preliminary' +code "observation-final": 'final' from "ObservationStatusCodes" display 'Final' +code "observation-amended": 'amended' from "ObservationStatusCodes" display 'Amended' +code "observation-corrected": 'corrected' from "ObservationStatusCodes" display 'Corrected' +code "observation-cancelled": 'cancelled' from "ObservationStatusCodes" display 'Cancelled' +code "observation-entered-in-error": 'entered-in-error' from "ObservationStatusCodes" display 'Entered in Error' +code "observation-unknown": 'unknown' from "ObservationStatusCodes" display 'Unknown' + +context Patient + +/* Candidates for FHIRCommon */ + +/* +@description: Returns true if the given condition has a clinical status of active, recurrence, or relapse +*/ +define fluent function isActive(condition USCore.Condition): + condition.clinicalStatus ~ "active" + or condition.clinicalStatus ~ "recurrence" + or condition.clinicalStatus ~ "relapse" + +define fluent function active(conditions List<USCore.Condition>): + conditions C + where C.clinicalStatus ~ "active" + or C.clinicalStatus ~ "recurrence" + or C.clinicalStatus ~ "relapse" + +define fluent function isAllergyActive(allergyIntolerance USCore.AllergyIntolerance): + allergyIntolerance.clinicalStatus ~ "allergy-active" + +define fluent function allergyActive(allergyIntolerances List<USCore.AllergyIntolerance>): + allergyIntolerances A + where A.clinicalStatus ~ "allergy-active" + +define fluent function isAllergyInactive(allergyIntolerance USCore.AllergyIntolerance): + allergyIntolerance.clinicalStatus ~ "allergy-inactive" + +define fluent function allergyInactive(allergyIntolerances List<USCore.AllergyIntolerance>): + allergyIntolerances A + where A.clinicalStatus ~ "allergy-inactive" + +define fluent function isAllergyResolved(allergyIntolerance USCore.AllergyIntolerance): + allergyIntolerance.clinicalStatus ~ "allergy-resolved" + +define fluent function allergyResolved(allergyIntolerances List<USCore.AllergyIntolerance>): + allergyIntolerances A + where A.clinicalStatus ~ "allergy-resolved" + +define fluent function isAllergyConfirmed(allergyIntolerance USCore.AllergyIntolerance): + allergyIntolerance.verificationStatus ~ "allergy-confirmed" + +define fluent function allergyConfirmed(allergyIntolerances List<USCore.AllergyIntolerance>): + allergyIntolerances A + where A.verificationStatus ~ "allergy-confirmed" + +define fluent function isAllergyUnconfirmed(allergyIntolerance USCore.AllergyIntolerance): + allergyIntolerance.verificationStatus ~ "allergy-unconfirmed" + +define fluent function allergyUnconfirmed(allergyIntolerances USCore.AllergyIntolerance): + allergyIntolerances A + where A.verificationStatus ~ "allergy-unconfirmed" + +define fluent function isAllergyRefuted(allergyIntolerance USCore.AllergyIntolerance): + allergyIntolerance.verificationStatus ~ "allergy-refuted" + +define fluent function allergyRefuted(allergyIntolerances USCore.AllergyIntolerance): + allergyIntolerances A + where A.verificationStatus ~ "allergy-refuted" + +/* +@description: Returns true if the given condition has the given category +*/ +define fluent function hasCategory(condition USCore.Condition, category Code): + exists (condition.category C + where C ~ category + ) + +/* +@description: Returns true if the given condition is a problem list item. +*/ +define fluent function isProblemListItem(condition USCore.Condition): + exists (condition.category C + where C ~ "problem-list-item" + ) + +/* +@description: Returns true if the given condition is an encounter diagnosis +*/ +define fluent function isEncounterDiagnosis(condition USCore.Condition): + exists (condition.category C + where C ~ "encounter-diagnosis" + ) + +/* +@description: Returns true if the given condition is a health concern +*/ +define fluent function isHealthConcern(condition USCore.Condition): + exists (condition.category C + where C ~ "health-concern" + ) + +define fluent function isUnconfirmed(condition USCore.Condition): + condition.verificationStatus ~ "unconfirmed" + +define fluent function unconfirmed(conditions List<USCore.Condition>): + conditions C + where C.verificationStatus ~ "unconfirmed" + +define fluent function isProvisional(condition USCore.Condition): + condition.verificationStatus ~ "provisional" + +define fluent function provisional(conditions List<USCore.Condition>): + conditions C + where C.verificationStatus ~ "provisional" + +define fluent function isDifferential(condition USCore.Condition): + condition.verificationStatus ~ "differential" + +define fluent function differential(conditions List<USCore.Condition>): + conditions C + where C.verificationStatus ~ "differential" + +define fluent function isConfirmed(condition USCore.Condition): + condition.verificationStatus ~ "confirmed" + +define fluent function confirmed(conditions List<USCore.Condition>): + conditions C + where C.verificationStatus ~ "confirmed" + +define fluent function isRefuted(condition USCore.Condition): + condition.verificationStatus ~ "refuted" + +define fluent function refuted(conditions List<USCore.Condition>): + conditions C + where C.verificationStatus ~ "refuted" + +/* +@description: Returns true if the given observation has the given category +*/ +define fluent function hasCategory(observation LaboratoryResultObservationProfile, category Code): + exists (observation.category C + where C ~ category + ) + +/* +@description: Returns true if the given observation has status +*/ +define fluent function isResulted(observation LaboratoryResultObservationProfile): + observation.status ~ "observation-final".code + or observation.status ~ "observation-amended".code + or observation.status ~ "observation-corrected".code + +define fluent function resulted(observations List<LaboratoryResultObservationProfile>): + observations observation + where observation.status ~ "observation-final".code + or observation.status ~ "observation-amended".code + or observation.status ~ "observation-corrected".code + +define fluent function isFinal(observation LaboratoryResultObservationProfile): + observation.status ~ "observation-final".code + +define fluent function final(observations List<LaboratoryResultObservationProfile>): + observations observation + where observation.status ~ "observation-final".code + +define fluent function isAmended(observation LaboratoryResultObservationProfile): + observation.status ~ "observation-amended".code + +define fluent function amended(observations List<LaboratoryResultObservationProfile>): + observations observation + where observation.status ~ "observation-amended".code + +define fluent function isCorrected(observation LaboratoryResultObservationProfile): + observation.status ~ "observation-corrected".code + +define fluent function corrected(observations List<LaboratoryResultObservationProfile>): + observations observation + where observation.status ~ "observation-corrected".code + + +define fluent function isResulted(observation "observation-bodyweight"): + observation.status ~ "observation-final".code + or observation.status ~ "observation-amended".code + or observation.status ~ "observation-corrected".code + +define fluent function resulted(observations List<"observation-bodyweight">): + observations observation + where observation.status ~ "observation-final".code + or observation.status ~ "observation-amended".code + or observation.status ~ "observation-corrected".code + +define fluent function isFinal(observation "observation-bodyweight"): + observation.status ~ "observation-final".code + +define fluent function final(observations List<"observation-bodyweight">): + observations observation + where observation.status ~ "observation-final".code + +define fluent function isAmended(observation "observation-bodyweight"): + observation.status ~ "observation-amended".code + +define fluent function amended(observations List<"observation-bodyweight">): + observations observation + where observation.status ~ "observation-amended".code + +define fluent function isCorrected(observation "observation-bodyweight"): + observation.status ~ "observation-corrected".code + +define fluent function corrected(observations List<"observation-bodyweight">): + observations observation + where observation.status ~ "observation-corrected".code + + +define fluent function isResulted(observation "observation-bodyheight"): + observation.status ~ "observation-final".code + or observation.status ~ "observation-amended".code + or observation.status ~ "observation-corrected".code + +define fluent function resulted(observations List<"observation-bodyheight">): + observations observation + where observation.status ~ "observation-final".code + or observation.status ~ "observation-amended".code + or observation.status ~ "observation-corrected".code + +define fluent function isFinal(observation "observation-bodyheight"): + observation.status ~ "observation-final".code + +define fluent function final(observations List<"observation-bodyheight">): + observations observation + where observation.status ~ "observation-final".code + +define fluent function isAmended(observation "observation-bodyheight"): + observation.status ~ "observation-amended".code + +define fluent function amended(observations List<"observation-bodyheight">): + observations observation + where observation.status ~ "observation-amended".code + +define fluent function isCorrected(observation "observation-bodyheight"): + observation.status ~ "observation-corrected".code + +define fluent function corrected(observations List<"observation-bodyheight">): + observations observation + where observation.status ~ "observation-corrected".code + return observation.status + +/* +@description: Returns true if the given MedicationRequest has a category of Community +*/ +define fluent function isCommunity(medicationRequest MedicationRequestProfile): + exists (medicationRequest.category C + where C ~ Community + ) + +/* +@description: Returns true if the given MedicationRequest has a category of Discharge +*/ +define fluent function isDischarge(medicationRequest MedicationRequestProfile): + exists (medicationRequest.category C + where C ~ Discharge + ) + +/* +@description: Returns true if the given MedicationRequest has the given category +*/ +define fluent function hasCategory(medicationRequest MedicationRequestProfile, category Code): + exists (medicationRequest.category C + where C ~ category + ) + +/* +@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval +@comment: Normalizes a choice type of DateTime, Quanitty, Interval<DateTime>, or Interval<Quantity> types +to an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible +representations for timing-valued elements in QICore, allowing this function to be used across any resource. +The input can be provided as a DateTime, Quantity, Interval<DateTime> or Interval<Quantity>. +The intent of this function is to provide a clear and concise mechanism to treat single +elements that have multiple possible representations as intervals so that logic doesn't have to account +for the variability. More complex calculations (such as medication request period or dispense period +calculation) need specific guidance and consideration. That guidance may make use of this function, but +the focus of this function is on single element calculations where the semantics are unambiguous. +If the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime. +If the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age, +and the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later. +If the input is a DateTime Interval, the result is the input. +If the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result +is a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending +immediately before one year later than the date the patient turned the age given as the end of the quantity interval. +Any other input will reslt in a null DateTime Interval +*/ +define fluent function toInterval(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>>): + case + when choice is DateTime then + Interval[choice as DateTime, choice as DateTime] + when choice is Interval<DateTime> then + choice as Interval<DateTime> + when choice is Quantity then + Interval[Patient.birthDate + (choice as Quantity), + Patient.birthDate + (choice as Quantity) + 1 year) + when choice is Interval<Quantity> then + Interval[Patient.birthDate + (choice.low as Quantity), + Patient.birthDate + (choice.high as Quantity) + 1 year) + else + null as Interval<DateTime> + end + +/* +@description: Returns an interval representing the normalized abatement of a given Condition. +@comment: If the abatement element of the Condition is represented as a DateTime, the result +is an interval beginning and ending on that DateTime. +If the abatement is represented as a Quantity, the quantity is expected to be a calendar-duration and is interpreted as the age of the patient. The +result is an interval from the date the patient turned that age to immediately before one year later. +If the abatement is represented as a Quantity Interval, the quantities are expected to be calendar-durations and are interpreted as an age range during +which the abatement occurred. The result is an interval from the date the patient turned the starting age of the quantity interval, and ending immediately +before one year later than the date the patient turned the ending age of the quantity interval. +*/ +define fluent function abatementInterval(condition USCore.Condition): + if condition.abatement is DateTime then + Interval[condition.abatement as DateTime, condition.abatement as DateTime] + else if condition.abatement is System.Quantity then + Interval[Patient.birthDate + (condition.abatement as System.Quantity), + Patient.birthDate + (condition.abatement as System.Quantity) + 1 year) + else if condition.abatement is Interval<System.Quantity> then + Interval[Patient.birthDate + (condition.abatement.low as System.Quantity), + Patient.birthDate + (condition.abatement.high as System.Quantity) + 1 year) + else if condition.abatement is Interval<DateTime> then + Interval[condition.abatement.low, condition.abatement.high) + else null as Interval<DateTime> + +/* +@description: Returns an interval representing the normalized prevalence period of a given Condition. +@comment: Uses the toInterval and abatementInterval functions to determine the widest potential interval from +onset to abatement as specified in the given Condition. If the condition is active, the resulting interval will have +a closed ending boundary. If the condition is not active, the resulting interval will have an open ending boundary. +*/ +define fluent function prevalenceInterval(condition USCore.Condition): +if condition.clinicalStatus ~ "active" + or condition.clinicalStatus ~ "recurrence" + or condition.clinicalStatus ~ "relapse" then + Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()] +else + Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()) + +/* +@description: Returns the tail of the given uri (i.e. everything after the last slash in the URI). +@comment: This function can be used to determine the logical id of a given resource. It can be used in +a single-server environment to trace references. However, this function does not attempt to resolve +or distinguish the base of the given url, and so cannot be used safely in multi-server environments. +*/ +define fluent function getId(uri String): + Last(Split(uri, '/')) + +/* +@description: Given an interval, return true if the interval has a starting boundary specified +(i.e. the start of the interval is not null and not the minimum DateTime value) +*/ +define fluent function hasStart(period Interval<DateTime> ): + not ( start of period is null + or start of period = minimum DateTime + ) + +/* +@description: Given an interval, returns true if the interval has an ending boundary specified +(i.e. the end of the interval is not null and not the maximum DateTime value) +*/ +define fluent function hasEnd(period Interval<DateTime> ): + not ( + end of period is null + or end of period = maximum DateTime + ) + +/* +@description: Given an interval, returns the ending point if the interval has an ending boundary specified, +otherwise, returns the starting point +*/ +define fluent function latest(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>> ): + (choice.toInterval()) period + return + if (period.hasEnd()) then end of period + else start of period + +/* +@description: Given an interval, return the starting point if the interval has a starting boundary specified, +otherwise, return the ending point +*/ +define fluent function earliest(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>> ): + (choice.toInterval()) period + return + if (period.hasStart()) then start of period + else end of period + +/* +@description: Returns the most recent Condition +*/ +define function MostRecent(conditions List<USCore.Condition>): + Last( + conditions C + sort by recordedDate + ) + +/* +@description: Return the most recent Observation +*/ +define function MostRecent(observations List<Observation>): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"SmokingStatusProfile">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"PulseOximetryProfile">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"PediatricWeightForHeightObservationProfile">): + Last( + observations O + sort by issued + ) + + define function MostRecent(observations List<"PediatricBMIforAgeObservationProfile">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"LaboratoryResultObservationProfile">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"observation-vitalspanel">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"observation-resprate">): + Last( + observations O + sort by issued + ) + + define function MostRecent(observations List<"observation-heartrate">): + Last( + observations O + sort by issued + ) + + define function MostRecent(observations List<"observation-oxygensat">): + Last( + observations O + sort by issued + ) + + define function MostRecent(observations List<"observation-bodytemp">): + Last( + observations O + sort by issued + ) + + define function MostRecent(observations List<"observation-headcircum">): + Last( + observations O + sort by issued + ) + + define function MostRecent(observations List<"observation-bp">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"observation-bmi">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"observation-bodyheight">): + Last( + observations O + sort by issued + ) + +define function MostRecent(observations List<"observation-bodyweight">): + Last( + observations O + sort by issued + ) + +define function MostRecentMR(medicationRequests List<"MedicationRequestProfile">): + Last( + medicationRequests MR + sort by authoredOn + ) + +define function MostRecentSR(serviceRequests List<FHIR.ServiceRequest>): + Last( + serviceRequests SR + sort by (FHIRHelpers.ToDateTime(authoredOn) as DateTime) + ) + + +define function Mobile(contactPoints List<USCore.ContactPoint>): + singleton from (contactPoints P where P.use = 'mobile') + diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreElements.cql b/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreElements.cql new file mode 100644 index 000000000..0089a960d --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreElements.cql @@ -0,0 +1,384 @@ +library USCoreElements version '0.1.0' + +using USCore version '3.1.1' + +include fhir.cqf.common.FHIRHelpers version '4.0.1' +include USCoreCommon version '0.1.0' called UC + +valueset "Common allergy substances": 'http://hl7.org/fhir/us/core/ValueSet/us-core-allergy-substance' + +code "No known allergy (situation)": '716186003' from UC.SNOMEDCT + +context Patient + +define "Usual Name": + First( + Patient.name name + where name.use ~ 'usual' + ) + +define "Official Name": + First( + Patient.name name + where name.use ~ 'official' + ) + +define "First Occurrence of Non-Official, Non-Usual Name": + First( + Patient.name name + where not(name.use ~ 'official') and not(name.use ~ 'usual') + ) + +define "Name": + Coalesce("Official Name", "Usual Name", "First Occurrence of Non-Official, Non-Usual Name") + +// TODO: Correct this once USCore.HumanName.given works as expected +// define "First Name": +// "Name".given[0] + +// TODO: Correct this once USCore.HumanName.given works as expected +// define "Middle Names": +// Combine(Skip("Name".given, 1), ' ') + +define "Last Name": + "Name".family + +// TODO: Correct this once USCore.HumanName.given works as expected +define "Name - First Middle(s) Last": + //Combine("Name".given, ' ') + ' ' + "Name".family + "Name".family + +// TODO: Correct this once USCore.HumanName.given works as expected +define "Name - Last, First Middle(s)": + //"Name".family + ', ' + Combine("Name".given, ' ') + "Name".family + +// Allergy/Intolerance + +/* +@description: Returns all allergies and intolerances +@comment: This definition returns all allergies and intolerances conforming to the US Core 3.1.1 +[AllergyIntolerance](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-allergyintolerance.html) profile. +Allergies and intolerances returned by this definition include records with any clinical status (including none) +and any verification status (including none). +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance +*/ +define "All Allergies and Intolerances": + ["AllergyIntolerance"] + +define "Active Confirmed Allergies and Intolerances": + "All Allergies and Intolerances".allergyActive().allergyConfirmed() + +define "Common Allergies and Intolerances": + "All Allergies and Intolerances" A + where A.code in "Common allergy substances" + +define "Active Confirmed Common Allergies and Intolerances": + "Common Allergies and Intolerances".allergyActive().allergyConfirmed() + +// No Known Allergies (Not Asked) +define "No Known Allergies (Not Asked)": + "All Allergies and Intolerances" A + where A.code ~ "No known allergy (situation)" + and A.isAllergyActive() + and A.isAllergyUnconfirmed() + +// No Known Allergies (Confirmed) +define "No Known Allergies (Confirmed)": + "All Allergies and Intolerances" A + where A.code ~ "No known allergy (situation)" + and A.isAllergyActive() + and A.isAllergyConfirmed() + +// Condition + +/* +@description: Returns all problem list items, encounter diagnoses, and health concerns +@comment: This definition returns all conditions of any category conforming to the US Core 3.1.1 +[Condition](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-condition.html) profile. +Conditions returned by this definition include records with any clinical status (including none) and +any verification status (including none). +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition +*/ +define "All Conditions": + ["Condition"] + +define "All Problem List Items": + "All Conditions" C + where C.isProblemListItem() + +define "Active Confirmed Problem List Items": + "All Problem List Items".active().confirmed() + +define "All Encounter Diagnoses": + "All Conditions" C + where C.isEncounterDiagnosis() + +define "All Health Concerns": + "All Conditions" C + where C.isHealthConcern() + +// Laboratory Diagnostic Report + +/* +@comment: [Diagnostic Report for Laboratory Results](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-lab.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab +*/ +define "All Diagnostic Reports for Laboratory Results": + ["DiagnosticReportProfileLaboratoryReporting"] + +// Diagnostic Report + +/* +@comment: [Diagnostic Report Note](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-note.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note +*/ +define "All Diagnostic Report Notes": + ["DiagnosticReportProfileNoteExchange"] + +// Encounter + +/* +@comment: [Encounter](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-encounter.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter +*/ +define "All Encounters": + ["EncounterProfile"] + +define "All Performed Encounters": + "All Encounters" E + where E.status = 'finished' + +// Immunization + +/* +@comment: [Immunization](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-immunization.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization +*/ +define "All Immunizations": + ["ImmunizationProfile"] + +define "All Completed Immunizations": + "All Immunizations" I + where I.status = 'completed' + +// Implantable Device + +/* +@comment: [Implantable Device](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-implantable-device.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device +*/ +define "All Implantable Devices": + ["ImplantableDeviceProfile"] + +// Laboratory Result + +/* +@description: Returns all laboratory results +@comment: [Laboratory Result](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-observation-lab.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab +*/ +define "All Laboratory Results": + ["LaboratoryResultObservationProfile"] + +define "Resulted Laboratory Results": + "All Laboratory Results" L + where L.status in { 'preliminary', 'final', 'amended', 'corrected' } + +// Medication Request + +/* +@description: Returns all medication requests +@comment: [Medication Request](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medicationrequest.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest +*/ +define "Most Recent Medication Request": + UC.MostRecentMR("All Medication Requests") + +define "All Medication Requests": + ["MedicationRequestProfile"] + +define "Active Medication Orders": + "All Medication Requests" M + where M.status = 'active' + and M.intent in { 'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order' } + +define "All Medications": + ["MedicationProfile"] + +// Pediatric BMI for Age + +/* +@comment: [Pediatric BMI for Age](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-bmi-for-age.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age +*/ +define "Pediatric BMI for Age": + ["PediatricBMIforAgeObservationProfile"] + +// Pediatric Head Circumference Percentile + +/* +@comment: [Pediatric Head Circumference Percentile](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-head-occipital-frontal-circumference-percentile.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/head-occipital-frontal-circumference-percentile +*/ +//define "All Pediatric Head Circumference Percentile Measurements": + //TODO - profile not in modelinfo + //UsCorePediatricHeadOccipitalFrontalCircumferencePercentileProfile + + +// Pediatric Weight for Height + +/* +@comment: [Pediatric Weight for Height](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-weight-for-height.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height +*/ +define "Pediatric Weight for Height": + ["PediatricWeightForHeightObservationProfile"] + +// Procedure + +/* +@comment: [Procedure](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-procedure.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure +*/ +define "All Procedures": + ["ProcedureProfile"] P + where P.status in { 'preparation', 'in-progress', 'on-hold', 'completed' } + +define "All Performed Procedures": + "All Procedures" P + where P.status = 'completed' + +// Pulse Oximetry + +/* +@comment: [Pulse Oximetry](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-pulse-oximetry.html) +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry +*/ +define "Pulse Oximetry": + ["PulseOximetryProfile"] + +// Smoking Status + +/* +@description: Returns all smoking status observations +@comment: This definition returns all smoking status observations conforming to the US Core 3.1.1 +[Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html) +profile. +@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus +*/ +define "Smoking Status": + ["SmokingStatusProfile"] + +/* +@description: Returns the most recent smoking status +@comment: This definition returns the most recent (by issued time) smoking status observation conforming to the +US Core 3.1.1 [Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html) +profile. +*/ +define "Most Recent Smoking Status": + Last( + "Smoking Status" SS + where SS.status = 'final' + sort by issued + ) + +// Vital Signs Panel + +/* +@comment: [Vital Signs Panel](http://hl7.org/fhir/R4/vitalspanel.html) +@profile: http://hl7.org/fhir/StructureDefinition/vitalspanel +*/ +define "All Vital Signs Panels": + ["observation-vitalspanel"] + +// Respiratory Rate + +/* +@comment: [Respiratory Rate](http://hl7.org/fhir/R4/resprate.html) +@profile: http://hl7.org/fhir/StructureDefinition/resprate +*/ +define "All Respiratory Rate Measurements": + ["observation-resprate"] + +// Heart Rate + +/* +@comment: [Heart Rate](http://hl7.org/fhir/R4/heartrate.html) +@profile:http://hl7.org/fhir/StructureDefinition/heartrate +*/ +define "All Heart Rate Measurements": + ["observation-heartrate"] + +// Oxygen Saturation + +/* +@comment: [Oxygen Saturation](http://hl7.org/fhir/R4/oxygensat.html) +@profile: http://hl7.org/fhir/StructureDefinition/oxygensat +*/ +define "All Oxygen Saturation Measurements": + ["observation-oxygensat"] + +// Body Temperature + +/* +@comment: [Body Temperature](http://hl7.org/fhir/R4/bodytemp.html) +@profile: http://hl7.org/fhir/StructureDefinition/bodytemp +*/ +define "All Body Temperature Measurements": + ["observation-bodytemp"] + +// Body Height + +/* +@comment: [Body Height](http://hl7.org/fhir/R4/bodyheight.html) +@profile: http://hl7.org/fhir/StructureDefinition/bodyheight +*/ +define "All Body Height Measurements": + ["observation-bodyheight"] + +// Head Circumference + +/* +@comment: [Head Circumference](http://hl7.org/fhir/R4/headcircum.html) +@profile: http://hl7.org/fhir/StructureDefinition/headcircum +*/ +define "All Head Circumference Measurements": + ["observation-headcircum"] + +// Body Weight + +/* +@comment: [Body Weight](http://hl7.org/fhir/R4/bodyweight.html) +@profile: http://hl7.org/fhir/StructureDefinition/bodyweight +*/ +define "All Body Weight Measurements": + ["observation-bodyweight"] + +// Body Mass Index + +/* +@comment: [Body Mass Index](http://hl7.org/fhir/R4/bmi.html) +@profile: http://hl7.org/fhir/StructureDefinition/bmi +*/ +define "All Body Mass Index Measurements": + ["observation-bmi"] + +// Blood Pressure + +/* +@comment: [Blood Pressure](http://hl7.org/fhir/R4/bp.html) +@profile: http://hl7.org/fhir/StructureDefinition/bp +*/ +define "All Blood Pressure Measurements": + ["observation-bp"] + +// Systolic Blood Pressure +define "Systolic Blood Pressure": + "All Blood Pressure Measurements".SystolicBP.value + +// Diastolic Blood Pressure +define "Diastolic Blood Pressure": + "All Blood Pressure Measurements".DiastolicBP.value + + diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreTests.cql b/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreTests.cql new file mode 100644 index 000000000..ab8a121c0 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/USCoreTests.cql @@ -0,0 +1,98 @@ +/* +@description: This is a testing library used to validate capability of the CQL-to-ELM translator +using the US Core model info. It is not intended as +*/ +library USCoreTests version '0.1.0' + +using USCore version '3.1.1' + +include fhir.cqf.common.FHIRHelpers version '4.0.1' + +codesystem "Marital Status Codes": 'http://terminology.hl7.org/CodeSystem/v3-MaritalStatus' +codesystem "CDC Race and Ethnicity Codes": 'urn:oid:2.16.840.1.113883.6.238' + +valueset "Marital Status": 'http://hl7.org/fhir/ValueSet/marital-status' + +code "Marital Status - Married": 'M' from "Marital Status Codes" +code "American Indian or Alaska Native": '1002-5' from "CDC Race and Ethnicity Codes" +code "Alaska Native": '1735-0' from "CDC Race and Ethnicity Codes" + +context Patient + +define TestPatient: ["PatientProfile"] +define TestAllergyIntolerance: ["AllergyIntolerance"] +define TestCarePlan: ["CarePlanProfile"] +define TestCareTeam: ["CareTeam"] +define TestCondition: ["Condition"] +define TestDiagnosticReport: ["DiagnosticReportProfileLaboratoryReporting"] +define TestDiagnosticReportNote: ["DiagnosticReportProfileNoteExchange"] +define TestDocumentReference: ["DocumentReferenceProfile"] +define TestEncounter: ["EncounterProfile"] +define TestGoal: ["GoalProfile"] +define TestImmunization: ["ImmunizationProfile"] +define TestImplantableDevice: ["ImplantableDeviceProfile"] +define TestObservation: ["LaboratoryResultObservationProfile"] +define TestLocation: ["Location"] +define TestMedication: ["MedicationProfile"] +define TestMedicationRequest: ["MedicationRequestProfile"] +define TestOrganization: ["OrganizationProfile"] +define TestVitalsPanel: ["observation-vitalspanel"] +define TestVitalsPanel2: ["Observation Vital Signs Panel Profile"] +define TestRespRate: ["observation-resprate"] +define TestRespRate2: ["Observation Respiratory Rate Profile"] +define TestHeartRate: ["observation-heartrate"] +define TestHeartRate2: ["Observation Heart Rate Profile"] +define TestOxygenSat: ["observation-oxygensat"] +define TestOxygenSat2: ["Observation Oxygen Saturation Profile"] +define TestBodyTemp: ["observation-bodytemp"] +define TestBodyTemp2: ["Observation Body Temperature Profile"] +define TestBodyHeight: ["observation-bodyheight"] +define TestBodyHeight2: ["Observation Body Height Profile"] +define TestHeadCircum: ["observation-headcircum"] +define TestHeadCircum2: ["Observation Head Circumference Profile"] +define TestBodyWeight: ["observation-bodyweight"] +define TestBodyWeight2: ["Observation Body Weight Profile"] +define TestBMI: ["observation-bmi"] +define TestBMI2: ["Observation Body Mass Index Profile"] + +define TestBP: ["observation-bp"] +define TestBP2: ["Observation Blood Pressure Profile"] +define TestSmokingStatus: ["SmokingStatusProfile"] +define TestPulseOximetry: ["PulseOximetryProfile"] +define TestPediatricBMIForAge: ["PediatricBMIforAgeObservationProfile"] +define TestPediatricWeightForHeight: ["PediatricWeightForHeightObservationProfile"] +define TestPractitioner: ["PractitionerProfile"] +define TestPractitionerRole: ["PractitionerRoleProfile"] +define TestProcedure: ["ProcedureProfile"] +define TestProvenance: ["Provenance"] + +define TestPrimitives: + Patient P + where P.gender = 'male' + and P.active is true + and P.birthDate before Today() + and P.maritalStatus in "Marital Status" + and P.maritalStatus ~ "Marital Status - Married" + +define TestChoice: + Patient P + where P.deceased is false + or P.deceased before Today() + +define TestSlices: + ["observation-bp"] BP + where BP.SystolicBP.value < 140 'mm[Hg]' + and BP.DiastolicBP.value < 90 'mm[Hg]' + +define TestSimpleExtensions: + Patient P + where P.birthsex = 'M' + +define TestComplexExtensions: + Patient P + where P.race.ombCategory contains "American Indian or Alaska Native" + and P.race.detailed contains "Alaska Native" + +define TestComplexFHIRHelpers: + ["PediatricBMIforAgeObservationProfile"] PB + return PB.VSCat \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/cql/cql-options.json b/tooling/src/test/resources/NewRefreshIG/input/cql/cql-options.json new file mode 100644 index 000000000..7a368b316 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/cql/cql-options.json @@ -0,0 +1,16 @@ +{ + "options":[ + "EnableLocators", + "DisableListDemotion", + "DisableListPromotion", + "EnableAnnotations" +], + "formats":[ + "XML", + "JSON" + ], + "validateUnits":true, + "verifyOnly":false, + "errorLevel":"Info", + "signatureLevel":"None" +} diff --git a/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-CumulativeMedicationDuration.json b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-CumulativeMedicationDuration.json new file mode 100644 index 000000000..3ea537d03 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-CumulativeMedicationDuration.json @@ -0,0 +1,69 @@ +{ + "resourceType": "Library", + "id": "CumulativeMedicationDuration", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/cqf/us/common/Library/CumulativeMedicationDuration", + "version": "3.1.000", + "name": "CumulativeMedicationDuration", + "relatedArtifact": [ { + "type": "depends-on", + "display": "USCore model information", + "resource": "http://hl7.org/fhir/Library/USCore-ModelInfo" + }, { + "type": "depends-on", + "display": "FHIR model information", + "resource": "http://fhir.org/guides/cqf/common/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Library USCoreCommon", + "resource": "http://fhir.org/guides/cqf/us/common/Library/USCoreCommon|0.1.0" + }, { + "type": "depends-on", + "display": "Code system V3TimingEvent", + "resource": "http://terminology.hl7.org/CodeSystem/v3-TimingEvent" + }, { + "type": "depends-on", + "display": "Code system EventTiming", + "resource": "http://hl7.org/fhir/event-timing" + }, { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + } ], + "parameter": [ { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + } ], + "dataRequirement": [ { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "/* 
@description: This library provides cumulative medication duration calculation
logic for use with FHIR medication prescription, administration, and dispensing
resources. The logic here follows the guidance provided as part of the 5.6
version of Quality Data Model.
@comment: Note that the logic here assumes single-instruction dosing information.
Split-dosing, tapering, and other more complex dosing instructions are not handled.
@update:
v0.2.000
Fixed Quantity handling in duration calculations
Fixed authorDatetime null handling
Changed to provide Date-level calculation, rather than DateTime
v2.0.000
Updated as part of 2022 AU refresh
Refactored to use QICoreCommon
v2.0.001
Fixed invalid unit error evaluating RolloutIntervals
Fixed RolloutIntervals incorrectly eliminating duplicates
v3.1.000
updated to reflect changes from AU2022 QDM library changes _JKR
*/
library CumulativeMedicationDuration version '3.1.000'

using USCore version '3.1.1'
// NOTE: Including FHIR to handle MedicationDispense and MedicationAdministration (not in USCore 3.1.1)
// TODO: Remove this reference once USCore supports MedicationDispense and MedicationAdministration
using FHIR version '4.0.1'

// NOTE: Removed in favor of USCore version '3.1.1'
//using QICore version '4.1.1'

// NOTE: Updated to 4.0.1 for now to simplify dependencies
// NOTE: include FHIRHelpers version '4.2.000'
include FHIRHelpers version '4.1.000'

// NOTE: Removed in favor of USCoreCommon
//include QICoreCommon version '1.3.000'
include USCoreCommon version '0.1.0'

// These code systems are not known to the MAT environment yet, request to have them added submitted
codesystem "V3TimingEvent": 'http://terminology.hl7.org/CodeSystem/v3-TimingEvent'
codesystem "EventTiming": 'http://hl7.org/fhir/event-timing'

code "HS": 'HS' from "V3TimingEvent" // event occurs [offset] before the hour of sleep (or trying to)
code "WAKE": 'WAKE' from "V3TimingEvent" // event occurs [offset] after waking
code "C": 'C' from "V3TimingEvent" //	event occurs at a meal (from the Latin cibus)
code "CM": 'CM' from "V3TimingEvent" //	event occurs at breakfast (from the Latin cibus matutinus)
code "CD": 'CD' from "V3TimingEvent" //	event occurs at lunch (from the Latin cibus diurnus)
code "CV": 'CV' from "V3TimingEvent" //	event occurs at dinner (from the Latin ante cibus vespertinus)
code "AC": 'AC' from "V3TimingEvent" //	event occurs [offset] before a meal (from the Latin ante cibus)
code "ACM": 'ACM' from "V3TimingEvent" //	event occurs [offset] before breakfast (from the Latin ante cibus matutinus)
code "ACD": 'ACD' from "V3TimingEvent" //	event occurs [offset] before lunch (from the Latin ante cibus diurnus)
code "ACV": 'ACV' from "V3TimingEvent" //	event occurs [offset] before dinner (from the Latin ante cibus vespertinus)
code "PC": 'PC' from "V3TimingEvent" //	event occurs [offset] after a meal (from the Latin post cibus)
code "PCM": 'PCM' from "V3TimingEvent" //	event occurs [offset] after breakfast (from the Latin post cibus matutinus)
code "PCD": 'PCD' from "V3TimingEvent" //	event occurs [offset] after lunch (from the Latin post cibus diurnus)
code "PCV": 'PCV' from "V3TimingEvent" //	event occurs [offset] after dinner (from the Latin post cibus vespertinus)

code "MORN": 'MORN' from EventTiming //	Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation.
code "MORN.early": 'MORN.early' from EventTiming //	Early Morning	Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation.
code "MORN.late": 'MORN.late' from EventTiming // Late Morning	Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation.
code "NOON": 'NOON' from EventTiming //	Noon	Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation.
code "AFT": 'AFT' from EventTiming //	Afternoon	Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
code "AFT.early": 'AFT.early' from EventTiming //	Early Afternoon	Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
code "AFT.late": 'AFT.late' from EventTiming //	Late Afternoon	Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
code "EVE": 'EVE' from EventTiming //	Evening	Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation.
code "EVE.early": 'EVE.early' from EventTiming //	Early Evening	Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation.
code "EVE.late": 'EVE.late' from EventTiming //	Late Evening	Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation.
code "NIGHT": 'NIGHT' from EventTiming //	Night	Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation.
code "PHS": 'PHS' from EventTiming //	After Sleep	Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation.

code "Every eight hours (qualifier value)": '307469008' from USCoreCommon."SNOMEDCT" display 'Every eight hours (qualifier value)'
code "Every eight to twelve hours (qualifier value)": '396140003' from USCoreCommon."SNOMEDCT" display 'Every eight to twelve hours (qualifier value)'
code "Every forty eight hours (qualifier value)": '396131002' from USCoreCommon."SNOMEDCT" display 'Every forty eight hours (qualifier value)'
code "Every forty hours (qualifier value)": '396130001' from USCoreCommon."SNOMEDCT" display 'Every forty hours (qualifier value)'
code "Every four hours (qualifier value)": '225756002' from USCoreCommon."SNOMEDCT" display 'Every four hours (qualifier value)'
code "Every seventy two hours (qualifier value)": '396143001' from USCoreCommon."SNOMEDCT" display 'Every seventy two hours (qualifier value)'
code "Every six hours (qualifier value)": '307468000' from USCoreCommon."SNOMEDCT" display 'Every six hours (qualifier value)'
code "Every six to eight hours (qualifier value)": '396139000' from USCoreCommon."SNOMEDCT" display 'Every six to eight hours (qualifier value)'
code "Every thirty six hours (qualifier value)": '396126004' from USCoreCommon."SNOMEDCT" display 'Every thirty six hours (qualifier value)'
code "Every three to four hours (qualifier value)": '225754004' from USCoreCommon."SNOMEDCT" display 'Every three to four hours (qualifier value)'
code "Every three to six hours (qualifier value)": '396127008' from USCoreCommon."SNOMEDCT" display 'Every three to six hours (qualifier value)'
code "Every twelve hours (qualifier value)": '307470009' from USCoreCommon."SNOMEDCT" display 'Every twelve hours (qualifier value)'
code "Every twenty four hours (qualifier value)": '396125000' from USCoreCommon."SNOMEDCT" display 'Every twenty four hours (qualifier value)'
code "Every two to four hours (qualifier value)": '225752000' from USCoreCommon."SNOMEDCT" display 'Every two to four hours (qualifier value)'
code "Four times daily (qualifier value)": '307439001' from USCoreCommon."SNOMEDCT" display 'Four times daily (qualifier value)'
code "Once daily (qualifier value)": '229797004' from USCoreCommon."SNOMEDCT" display 'Once daily (qualifier value)'
code "One to four times a day (qualifier value)": '396109005' from USCoreCommon."SNOMEDCT" display 'One to four times a day (qualifier value)'
code "One to three times a day (qualifier value)": '396108002' from USCoreCommon."SNOMEDCT" display 'One to three times a day (qualifier value)'
code "One to two times a day (qualifier value)": '396107007' from USCoreCommon."SNOMEDCT" display 'One to two times a day (qualifier value)'
code "Three times daily (qualifier value)": '229798009' from USCoreCommon."SNOMEDCT" display 'Three times daily (qualifier value)'
code "Twice a day (qualifier value)": '229799001' from USCoreCommon."SNOMEDCT" display 'Twice a day (qualifier value)'
code "Two to four times a day (qualifier value)": '396111001' from USCoreCommon."SNOMEDCT" display 'Two to four times a day (qualifier value)'

parameter ErrorLevel String default 'Warning'

context Patient

/*
 Goal is to get to number of days
 Two broad approaches to the calculation:
  1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered
  2) Based on relevant period, determine a covered interval and calculate the length of that interval in days

This topic covers several use cases and illustrates how to calculate Cumulative
Medication Duration for each type of medication resource using the supply and
frequency approach.
*/

/*
  For the first approach, we need to get from frequency to a frequency/day
  So we define ToDaily
*/

/*
  Calculates daily frequency given frequency within a period
*/
define function ToDaily(frequency System.Integer, period System.Quantity):
  case period.unit
    when 'h' then frequency * (24.0 / period.value)
    when 'min' then frequency * (24.0 / period.value) * 60
    when 's' then frequency * (24.0 / period.value) * 60 * 60
    when 'd' then frequency * (24.0 / period.value) / 24
    when 'wk' then frequency * (24.0 / period.value) / (24 * 7)
    when 'mo' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */
    when 'a' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */
    when 'hour' then frequency * (24.0 / period.value)
    when 'minute' then frequency * (24.0 / period.value) * 60
    when 'second' then frequency * (24.0 / period.value) * 60 * 60
    when 'day' then frequency * (24.0 / period.value) / 24
    when 'week' then frequency * (24.0 / period.value) / (24 * 7)
    when 'month' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */
    when 'year' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */
    when 'hours' then frequency * (24.0 / period.value)
    when 'minutes' then frequency * (24.0 / period.value) * 60
    when 'seconds' then frequency * (24.0 / period.value) * 60 * 60
    when 'days' then frequency * (24.0 / period.value) / 24
    when 'weeks' then frequency * (24.0 / period.value) / (24 * 7)
    when 'months' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */
    when 'years' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */
    else Message(null, true, 'CMDLogic.ToDaily.UnknownUnit', ErrorLevel, 'Unknown unit ' & period.unit)
  end

/*
  Returns a daily frequency for the given code representation of frequency.
  The function expects codes from the [EventTiming](http://hl7.org/fhir/codesystem-event-timing.html) or
  [V3TimingEvent](http://hl7.org/fhir/v3/TimingEvent/cs.html) code systems.
  // TODO: Determine whether or not we should use timing.code at all....
*/
define function ToDaily(frequency Code):
  case
    when frequency ~ "HS" then 1 // event occurs [offset] before the hour of sleep (or trying to)
    when frequency ~ "WAKE" then 1 // event occurs [offset] after waking
    when frequency ~ "C" then 3 //	event occurs at a meal (from the Latin cibus)
    when frequency ~ "CM" then 1 //	event occurs at breakfast (from the Latin cibus matutinus)
    when frequency ~ "CD" then 1 //	event occurs at lunch (from the Latin cibus diurnus)
    when frequency ~ "CV" then 1 //	event occurs at dinner (from the Latin ante cibus vespertinus)
    when frequency ~ "AC" then 3 //	event occurs [offset] before a meal (from the Latin ante cibus)
    when frequency ~ "ACM" then 1 //	event occurs [offset] before breakfast (from the Latin ante cibus matutinus)
    when frequency ~ "ACD" then 1 //	event occurs [offset] before lunch (from the Latin ante cibus diurnus)
    when frequency ~ "ACV" then 1 //	event occurs [offset] before dinner (from the Latin ante cibus vespertinus)
    when frequency ~ "PC" then 3 //	event occurs [offset] after a meal (from the Latin post cibus)
    when frequency ~ "PCM" then 1 //	event occurs [offset] after breakfast (from the Latin post cibus matutinus)
    when frequency ~ "PCD" then 1 //	event occurs [offset] after lunch (from the Latin post cibus diurnus)
    when frequency ~ "PCV" then 1 //	event occurs [offset] after dinner (from the Latin post cibus vespertinus)

    when frequency ~ "MORN" then 1 //	Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "MORN.early" then 1 //	Early Morning	Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "MORN.late" then 1 // Late Morning	Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "NOON" then 1 //	Noon	Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "AFT" then 1 //	Afternoon	Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "AFT.early" then 1 //	Early Afternoon	Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "AFT.late" then 1 //	Late Afternoon	Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "EVE" then 1 //	Evening	Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "EVE.early" then 1 //	Early Evening	Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "EVE.late" then 1 //	Late Evening	Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "NIGHT" then 1 //	Night	Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation.
    when frequency ~ "PHS" then 1 //	After Sleep	Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation.

    when frequency ~ "Once daily (qualifier value)" then 1.0
    when frequency ~ "Twice a day (qualifier value)" then 2.0
    when frequency ~ "Three times daily (qualifier value)" then 3.0
    when frequency ~ "Four times daily (qualifier value)" then 4.0
    when frequency ~ "Every twenty four hours (qualifier value)" then 1.0
    when frequency ~ "Every twelve hours (qualifier value)" then 2.0
    when frequency ~ "Every thirty six hours (qualifier value)" then 0.67
    when frequency ~ "Every eight hours (qualifier value)" then 3.0
    when frequency ~ "Every four hours (qualifier value)" then 6.0
    when frequency ~ "Every six hours (qualifier value)" then 4.0
    when frequency ~ "Every seventy two hours (qualifier value)" then 0.33
    when frequency ~ "Every forty eight hours (qualifier value)" then 0.5
    when frequency ~ "Every eight to twelve hours (qualifier value)" then 3.0
    when frequency ~ "Every six to eight hours (qualifier value)" then 4.0
    when frequency ~ "Every three to four hours (qualifier value)" then 8.0
    when frequency ~ "Every three to six hours (qualifier value)" then 8.0
    when frequency ~ "Every two to four hours (qualifier value)" then 12.0
    when frequency ~ "One to four times a day (qualifier value)" then 4.0
    when frequency ~ "One to three times a day (qualifier value)" then 3.0
    when frequency ~ "One to two times a day (qualifier value)" then 2.0
    when frequency ~ "Two to four times a day (qualifier value)" then 4.0

    else Message(null, true, 'CMDLogic.ToDaily.UnknownFrequencyCode', ErrorLevel, 'Unknown frequency code ' & frequency.code)
  end

/*
Now that we have a ToDaily function, we can approach calculation of the
duration of medication for an order. First, consider the definitions
for each element:

* 1 and only 1 dosageInstruction
* 1 and only 1 doseAndRate
* 1 timing with 1 repeat
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* doseQuantity or doseRange
* timeOfDay

* authoredOn: The date the prescription was written
* dispenseRequest.validityPeriod: Time period supply is authorized for
* dispenseRequest.quantity: amount of medication supplied per dispense
* dispenseRequest.numberOfRepeatsAllowed: number of refills authorized
* dispenseRequest.expectedSupplyDuration: number of days supply per dispense
* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat
* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat
* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat
* dosageInstruction.timing.repeat.count: number of times to repeat
* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat
* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period
* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period
* dosageInstruction.timing.repeat.period: event occurs frequency times per period
* dosageInstruction.timing.repeat.periodMax: upper limit of period
* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a)
* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*)
* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...)
* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD...
* dosageInstruction.asNeeded
* dosageInstruction.doseAndRate.doseQuantity
* dosageInstruction.doseAndRate.doseRange

If expectedSupplyDuration is present, then the duration is

    expectedSupplyDuration * (1 + numberOfRepeatsAllowed)

If expectedSupplyDuration is not present, then it must be calculated based on the quantity, dosage, and frequency:

    (quantity / (dosage * frequency)) * (1 + numberOfRepeatsAllowed)

    dosage: Coalesce(end of doseAndRate.doseRange, doseAndRate.doseQuantity)
    frequency: Coalesce(frequencyMax, frequency)
    period: Quantity(period, periodUnit)

If expectedSupplyDuration is not present and cannot be calculated, and the boundsPeriod is present (and completely specified), we can use that directly

    dosage.timing.repeat.boundsPeriod

This calculation results in a number of days, which can then be turned into a period by anchoring that to the
start of the validityPeriod or the authoredOn:

    Interval[earliestDispensable, earliestDispensable + expectedSupplyDuration - 1]

    earliestDispensable: Coalesce(start of validityPeriod, authoredOn)

The following function illustrates this completely:
*/

/*
Calculates the Medication Period for a single MedicationRequest.
MedicationRequest instances provided to this function are expected
to conform to the [MMEMedicationRequest](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationrequest.html)
profile, which expects:
* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error
* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error
* 1 timing with 1 repeat, missing timing or repeat elements will result in a null
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* timeOfDay
* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null
Note that MedicationRequest status is not considered by this calculation, as the
list of MedicationRequest instances provided to this function should already have
considered appropriate statuses, depending on the use case, typically `completed`.

NOTE: Updated return to use "date from end of boundsPeriod" to ensure result is Interval<Date>
*/
define function MedicationRequestPeriodTest(Request USCore."MedicationRequestProfile"):
  Request R
    let
      dosage: singleton from R.dosageInstruction,
      doseAndRate: singleton from dosage.doseAndRate,
      timing: dosage.timing,
      frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency),
      period: Quantity(timing.repeat.period, timing.repeat.periodUnit),
      doseRange: doseAndRate.dose,
      doseQuantity: doseAndRate.dose,
      dose: Coalesce(end of doseRange, doseQuantity),
      dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0),
      boundsPeriod: timing.repeat.bounds as Interval<DateTime>,
      expectedDaysSupply: R.dispenseRequest.expectedSupplyDuration.value,
      // TODO: this isn't working as expected, convert results in null
      //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value,
      daysSupply: (R.dispenseRequest.expectedSupplyDuration).value,
      quantity: R.dispenseRequest.quantity,
      refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0),
      startDate:
        Coalesce(
          date from start of boundsPeriod,
          date from R.authoredOn,
          date from start of R.dispenseRequest.validityPeriod
        ),
      totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills)
    return { dosage: dosage, doseAndRate: doseAndRate, timing: timing, frequency: frequency, period: period,
      doseRange: doseRange, doseQuantity: doseQuantity, dose: dose, dosesPerDay: dosesPerDay, boundsPeriod: boundsPeriod,
      expectedDaysSupply: expectedDaysSupply, daysSupply: daysSupply, quantity: quantity, refills: refills, startDate: startDate, totalDaysSupplied: totalDaysSupplied,
      requestPeriod: if startDate is not null and totalDaysSupplied is not null then
        Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ]
      else if startDate is not null and boundsPeriod."high" is not null then
        Interval[startDate, date from end of boundsPeriod]
      else
        null}

define function MedicationRequestPeriod(Request USCore."MedicationRequestProfile"):
  Request R
    let
      dosage: singleton from R.dosageInstruction,
      doseAndRate: singleton from dosage.doseAndRate,
      timing: dosage.timing,
      frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency),
      period: Quantity(timing.repeat.period, timing.repeat.periodUnit),
      doseRange: doseAndRate.dose,
      doseQuantity: doseAndRate.dose,
      dose: Coalesce(end of doseRange, doseQuantity),
      dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0),
      boundsPeriod: timing.repeat.bounds as Interval<DateTime>,
      // TODO: this isn't working as expected, convert results in null
      //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value,
      daysSupply: (R.dispenseRequest.expectedSupplyDuration).value,
      quantity: R.dispenseRequest.quantity,
      refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0),
      startDate:
        Coalesce(
          date from start of boundsPeriod,
          date from R.authoredOn,
          date from start of R.dispenseRequest.validityPeriod
        ),
      totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills)
    return
      if startDate is not null and totalDaysSupplied is not null then
        Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ]
      else if startDate is not null and boundsPeriod."high" is not null then
        Interval[startDate, date from end of boundsPeriod]
      else
        null

/*
Next, consider the MedicationDispense case:

* whenPrepared: When product was prepared
* whenHandedOver: When product was given out
* quantity: Amount dispensed
* daysSupply: Amount of medication expressed as a timing amount
* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat
* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat
* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat
* dosageInstruction.timing.repeat.count: number of times to repeat
* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat
* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period
* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period
* dosageInstruction.timing.repeat.period: event occurs frequency times per period
* dosageInstruction.timing.repeat.periodMax: upper limit of period
* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a)
* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*)
* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...)
* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD...
* dosageInstruction.asNeeded
* dosageInstruction.doseAndRate.doseQuantity
* dosageInstruction.doseAndRate.doseRange

We have effectively the same elements, with the same meanings, with the exception that the
event is documenting a single dispense, and does not contain refill information. In addition,
multiple dispense events would typically be present, and those would all have to be considered
as part of an overall calculation. That will be considered when we combine results, but for
this function, we'll focus on calculating the duration of a single dispense.

With a MedicationDispense, dosage information is expected to be the same as the related
MedicationRequest, so boundsPeriod would still cover the entire prescription (including refills)
and so cannot be used to calculate the interval covered by the dispense.

If the daysSupply element is present, then the duration in days is simply

    daysSupply

Note specifically that we are not considering refills, as those would be covered
by subsequent dispense records.

If daysSupplied is not present, then daysSupplied must be calculated based on
the quantity, dosage, and frequency:

    (quantity / (dosage * frequency))

This calculation results in a number of days, which can then be turned into a
period by anchoring that to the startDate, as determined by the first available
value of the start of the boundsPeriod, whenHandedOver, and whenPrepared.

   Interval[startDate, startDate + totalDaysSupplied - 1 day]
*/

/*
Calculates Medication Period for a given MedicationDispense
MedicationDispense instances provided to this function are expected
to conform to the [TODO: MMEMedicationDispense](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationdispense.html)
profile, which expects:
* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error
* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error
* 1 timing with 1 repeat, missing timing or repeat elements will result in a null
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* timeOfDay
* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null
* whenHandedOver or whenPrepared, if missing both whenHandedOver and whenPrepared will result in a null

Note that MedicationDispense status is not considered by this calculation, as the
list of MedicationDispense instances provided to this function should already have
considered appropriate statuses, depending on the use case, typically `completed`,
especially since whenHandedOver would be expected to be present for a completed
MedicationDispense.

Note also that the dosage information recorded in a dispense is expected to be a copy of the
dispense information from the related medication request. As such, the boundsPeriod would be expected
to cover the entire range, and should _not_ be used for timing of the event.

There is also active discussion in the Pharmacy WG about what date should be used if whenPrepared/whenHandedOver is not present.
This may take the form of an "original creation date", but may also be a "status change date" for dispense events that are updating
status of an existing dispense. That discussion is ongoing, so until that is resolved, this logic will return
null if whenPrepared/whenHandedOver are not available.
*/
define function MedicationDispensePeriod(Dispense "MedicationDispense"):
  Dispense D
    let
      dosage: singleton from D.dosageInstruction,
      doseAndRate: singleton from dosage.doseAndRate,
      timing: dosage.timing,
      frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency),
      period: Quantity(timing.repeat.period, timing.repeat.periodUnit),
      doseRange: doseAndRate.dose,
      doseQuantity: doseAndRate.dose,
      dose: Coalesce(end of doseRange, doseQuantity),
      daysSupply: (convert D.daysSupply to days).value,
      dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0),
      startDate:
        Coalesce(
          date from D.whenHandedOver,
          date from D.whenPrepared
        ),
      totalDaysSupplied: Coalesce(daysSupply, D.quantity.value / (dose.value * dosesPerDay))
    return
      if startDate is not null and totalDaysSupplied is not null then
        Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day')]
      else
        null

/*
Returns the established therapeutic duration for a given medication.
This is likely measure specific, though could potentially be established for
any drug and distributed as a CodeSystem supplement.
Defaulting to 14 days here for illustration.
*/
define function TherapeuticDuration(medication Concept):
  14 days

/*
Next we consider MedicationAdministration. This data type is typically used to
capture specific administration, with the relevantPeriod capturing start and stop
time of the administration event:

* effective[x]: Start and end time of administration

However, when calculating cumulative medication duration, it is typically the
therapeutic period of the medication that should be considered. Currently neither
the Medication nor MedicationKnowledge resources provide this information, so
we model it here as a function that can potentially be implemented in a variety
of ways, including measure-specific values, as well as distribution as an RxNorm
code system supplement.

However it is obtained, if therapeutic duration can be obtained, and the effective
period has a start, the result will be

    Interval[startDate, startDate + therapeuticDuration - 1 day]

NOTE: Therapeutic duration needs to be established and until a way is implemented to
do that based on the medication, this logic is incomplete and should not be used.
*/
define function MedicationAdministrationPeriod(Administration "MedicationAdministration"):
  Administration M
    let
      therapeuticDuration: TherapeuticDuration(Administration.medication),
      startDate: date from start of Administration.effective
    return
      if startDate is not null and therapeuticDuration is not null then
        Interval[startDate, startDate + therapeuticDuration - 1]
      else
        null

/*
Now that we have functions for determining the medication period for individual
prescriptions, administrations, and dispenses, we can combine those using
an overall cumulative medication duration calculation.

There are two broad approaches to calculating cumulative duration, one that _collapses_
overlapping intervals so that calculations are not duplicated, and one that _rolls out_
overlapping intervals so that the durations are laid end-to-end.

First, we define a function that simply calculates CumulativeDuration of a set of
intervals:

NOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>>
*/
define function CumulativeDuration(Intervals List<Interval<Date>>):
   if Intervals is not null then ( Sum((collapse Intervals per day)X
        return all(difference in days between start of X and 
          end of X
        )+ 1
    )
  ) 
    else null

/*
Next, we define a function that rolls out intervals:

NOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>>
*/
define function RolloutIntervals(intervals List<Interval<Date>>):
 intervals I aggregate all R starting ( null as List<Interval<Date>>): R
    union ( { I X
        let S: Max({ 
          end of Last(R)+ 1 day, start of X }
        ),
        E: S + Quantity(Coalesce(duration in days of X, 0), 'day')
        return Interval[S, E]}
    )

/*
Then, we define a function that allows us to calculate based on the various medication
types:
*/

define function MedicationPeriod(
  medication Choice<USCore."MedicationRequestProfile",
    "MedicationDispense"
  >):
  case
    when medication is USCore."MedicationRequestProfile" then MedicationRequestPeriod(medication)
    when medication is MedicationDispense then MedicationDispensePeriod(medication)
    else null
  end

/*
We can then use this function, combined with the MedicationDuration functions above
to calculate Cumulative Medication Duration:

Generally speaking, we want to _roll out_ intervals from dispense and administration
events, and then collapse across that result and intervals from prescriptions.

Note also that the separation of medications by type should already be done
by this stage as well.

Calculations that combine dosages from different types of medications (such as Morphine Milligram Equivalent (MME)
or Average MME) require further consideration.
*/

define function CumulativeMedicationDuration(
  Medications List<Choice<USCore."MedicationRequestProfile",
    "MedicationDispense"
  >>):
  CumulativeDuration((
      Medications M
        where M is MedicationRequest
        return MedicationRequestPeriod(M)
    )
      union (
        RolloutIntervals(
          Medications M
            where M is MedicationDispense
            return MedicationDispensePeriod(M)
        )
      )
  )


/**********************************************************************/
/* Functions in this region are copied from opioid-mme-r4             */
/**********************************************************************/

define function Quantity(value Decimal, unit String):
  if value is not null then
    System.Quantity { value: value, unit: unit }
  else
    null
" + }, { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1">
   <annotation translatorVersion="2.7.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:t name="description" value="This library provides cumulative medication duration calculation&#xa;logic for use with FHIR medication prescription, administration, and dispensing&#xa;resources. The logic here follows the guidance provided as part of the 5.6&#xa;version of Quality Data Model."/>
      <a:t name="comment" value="Note that the logic here assumes single-instruction dosing information.&#xa;Split-dosing, tapering, and other more complex dosing instructions are not handled."/>
      <a:t name="update" value="v0.2.000&#xa;Fixed Quantity handling in duration calculations&#xa;Fixed authorDatetime null handling&#xa;Changed to provide Date-level calculation, rather than DateTime&#xa;v2.0.000&#xa;Updated as part of 2022 AU refresh&#xa;Refactored to use QICoreCommon&#xa;v2.0.001&#xa;Fixed invalid unit error evaluating RolloutIntervals&#xa;Fixed RolloutIntervals incorrectly eliminating duplicates&#xa;v3.1.000&#xa;updated to reflect changes from AU2022 QDM library changes _JKR"/>
      <a:s r="1125">
         <a:s>/* 
@description: This library provides cumulative medication duration calculation
logic for use with FHIR medication prescription, administration, and dispensing
resources. The logic here follows the guidance provided as part of the 5.6
version of Quality Data Model.
@comment: Note that the logic here assumes single-instruction dosing information.
Split-dosing, tapering, and other more complex dosing instructions are not handled.
@update:
v0.2.000
Fixed Quantity handling in duration calculations
Fixed authorDatetime null handling
Changed to provide Date-level calculation, rather than DateTime
v2.0.000
Updated as part of 2022 AU refresh
Refactored to use QICoreCommon
v2.0.001
Fixed invalid unit error evaluating RolloutIntervals
Fixed RolloutIntervals incorrectly eliminating duplicates
v3.1.000
updated to reflect changes from AU2022 QDM library changes _JKR
*/
library CumulativeMedicationDuration version '3.1.000'</a:s>
      </a:s>
   </annotation>
   <identifier id="CumulativeMedicationDuration" system="http://fhir.org/guides/cqf/us/common" version="3.1.000"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="24:1-24:28" localIdentifier="USCore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="1">
               <a:s>using </a:s>
               <a:s>
                  <a:s>USCore</a:s>
               </a:s>
               <a:s> version '3.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="2" locator="27:1-27:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1">
         <annotation xsi:type="a:Annotation">
            <a:s r="2">
               <a:s>// NOTE: Including FHIR to handle MedicationDispense and MedicationAdministration (not in USCore 3.1.1)
// TODO: Remove this reference once USCore supports MedicationDispense and MedicationAdministration
using </a:s>
               <a:s>
                  <a:s>FHIR</a:s>
               </a:s>
               <a:s> version '4.0.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="3" locator="34:1-34:37" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/cqf/us/common/FHIRHelpers" version="4.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="3">
               <a:s>// NOTE: Removed in favor of USCore version '3.1.1'
//using QICore version '4.1.1'

// NOTE: Updated to 4.0.1 for now to simplify dependencies
// NOTE: include FHIRHelpers version '4.2.000'
include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.1.000'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="4" locator="38:1-38:36" localIdentifier="USCoreCommon" path="http://fhir.org/guides/cqf/us/common/USCoreCommon" version="0.1.0">
         <annotation xsi:type="a:Annotation">
            <a:s r="4">
               <a:s>// NOTE: Removed in favor of USCoreCommon
//include QICoreCommon version '1.3.000'
include </a:s>
               <a:s>
                  <a:s>USCoreCommon</a:s>
               </a:s>
               <a:s> version '0.1.0'</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <parameters>
      <def localId="105" locator="95:1-95:45" name="ErrorLevel" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="105">
               <a:s>parameter ErrorLevel </a:s>
               <a:s r="104">
                  <a:s>String</a:s>
               </a:s>
               <a:s> default </a:s>
               <a:s r="103">
                  <a:s>'Warning'</a:s>
               </a:s>
            </a:s>
         </annotation>
         <default localId="103" locator="95:37-95:45" valueType="t:String" value="Warning" xsi:type="Literal"/>
         <parameterTypeSpecifier localId="104" locator="95:22-95:27" name="t:String" xsi:type="NamedTypeSpecifier"/>
      </def>
   </parameters>
   <codeSystems>
      <def localId="5" locator="41:1-41:82" name="V3TimingEvent" id="http://terminology.hl7.org/CodeSystem/v3-TimingEvent" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="5">
               <a:s>// These code systems are not known to the MAT environment yet, request to have them added submitted
codesystem &quot;V3TimingEvent&quot;: 'http://terminology.hl7.org/CodeSystem/v3-TimingEvent'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="6" locator="42:1-42:60" name="EventTiming" id="http://hl7.org/fhir/event-timing" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="6">
               <a:s>codesystem &quot;EventTiming&quot;: 'http://hl7.org/fhir/event-timing'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <codes>
      <def localId="8" locator="44:1-44:36" name="HS" id="HS" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="8">
               <a:s>code &quot;HS&quot;: 'HS' from </a:s>
               <a:s r="7">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="7" locator="44:22-44:36" name="V3TimingEvent"/>
      </def>
      <def localId="10" locator="45:1-45:40" name="WAKE" id="WAKE" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="10">
               <a:s>// event occurs [offset] before the hour of sleep (or trying to)
code &quot;WAKE&quot;: 'WAKE' from </a:s>
               <a:s r="9">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="9" locator="45:26-45:40" name="V3TimingEvent"/>
      </def>
      <def localId="12" locator="46:1-46:34" name="C" id="C" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="12">
               <a:s>// event occurs [offset] after waking
code &quot;C&quot;: 'C' from </a:s>
               <a:s r="11">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="11" locator="46:20-46:34" name="V3TimingEvent"/>
      </def>
      <def localId="14" locator="47:1-47:36" name="CM" id="CM" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="14">
               <a:s>//	event occurs at a meal (from the Latin cibus)
code &quot;CM&quot;: 'CM' from </a:s>
               <a:s r="13">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="13" locator="47:22-47:36" name="V3TimingEvent"/>
      </def>
      <def localId="16" locator="48:1-48:36" name="CD" id="CD" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="16">
               <a:s>//	event occurs at breakfast (from the Latin cibus matutinus)
code &quot;CD&quot;: 'CD' from </a:s>
               <a:s r="15">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="15" locator="48:22-48:36" name="V3TimingEvent"/>
      </def>
      <def localId="18" locator="49:1-49:36" name="CV" id="CV" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="18">
               <a:s>//	event occurs at lunch (from the Latin cibus diurnus)
code &quot;CV&quot;: 'CV' from </a:s>
               <a:s r="17">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="17" locator="49:22-49:36" name="V3TimingEvent"/>
      </def>
      <def localId="20" locator="50:1-50:36" name="AC" id="AC" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="20">
               <a:s>//	event occurs at dinner (from the Latin ante cibus vespertinus)
code &quot;AC&quot;: 'AC' from </a:s>
               <a:s r="19">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="19" locator="50:22-50:36" name="V3TimingEvent"/>
      </def>
      <def localId="22" locator="51:1-51:38" name="ACM" id="ACM" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="22">
               <a:s>//	event occurs [offset] before a meal (from the Latin ante cibus)
code &quot;ACM&quot;: 'ACM' from </a:s>
               <a:s r="21">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="21" locator="51:24-51:38" name="V3TimingEvent"/>
      </def>
      <def localId="24" locator="52:1-52:38" name="ACD" id="ACD" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="24">
               <a:s>//	event occurs [offset] before breakfast (from the Latin ante cibus matutinus)
code &quot;ACD&quot;: 'ACD' from </a:s>
               <a:s r="23">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="23" locator="52:24-52:38" name="V3TimingEvent"/>
      </def>
      <def localId="26" locator="53:1-53:38" name="ACV" id="ACV" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="26">
               <a:s>//	event occurs [offset] before lunch (from the Latin ante cibus diurnus)
code &quot;ACV&quot;: 'ACV' from </a:s>
               <a:s r="25">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="25" locator="53:24-53:38" name="V3TimingEvent"/>
      </def>
      <def localId="28" locator="54:1-54:36" name="PC" id="PC" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="28">
               <a:s>//	event occurs [offset] before dinner (from the Latin ante cibus vespertinus)
code &quot;PC&quot;: 'PC' from </a:s>
               <a:s r="27">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="27" locator="54:22-54:36" name="V3TimingEvent"/>
      </def>
      <def localId="30" locator="55:1-55:38" name="PCM" id="PCM" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="30">
               <a:s>//	event occurs [offset] after a meal (from the Latin post cibus)
code &quot;PCM&quot;: 'PCM' from </a:s>
               <a:s r="29">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="29" locator="55:24-55:38" name="V3TimingEvent"/>
      </def>
      <def localId="32" locator="56:1-56:38" name="PCD" id="PCD" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="32">
               <a:s>//	event occurs [offset] after breakfast (from the Latin post cibus matutinus)
code &quot;PCD&quot;: 'PCD' from </a:s>
               <a:s r="31">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="31" locator="56:24-56:38" name="V3TimingEvent"/>
      </def>
      <def localId="34" locator="57:1-57:38" name="PCV" id="PCV" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="34">
               <a:s>//	event occurs [offset] after lunch (from the Latin post cibus diurnus)
code &quot;PCV&quot;: 'PCV' from </a:s>
               <a:s r="33">
                  <a:s>&quot;V3TimingEvent&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="33" locator="57:24-57:38" name="V3TimingEvent"/>
      </def>
      <def localId="36" locator="59:1-59:36" name="MORN" id="MORN" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="36">
               <a:s>//	event occurs [offset] after dinner (from the Latin post cibus vespertinus)
code &quot;MORN&quot;: 'MORN' from </a:s>
               <a:s r="35">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="35" locator="59:26-59:36" name="EventTiming"/>
      </def>
      <def localId="38" locator="60:1-60:48" name="MORN.early" id="MORN.early" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="38">
               <a:s>//	Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;MORN.early&quot;: 'MORN.early' from </a:s>
               <a:s r="37">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="37" locator="60:38-60:48" name="EventTiming"/>
      </def>
      <def localId="40" locator="61:1-61:46" name="MORN.late" id="MORN.late" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="40">
               <a:s>//	Early Morning	Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;MORN.late&quot;: 'MORN.late' from </a:s>
               <a:s r="39">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="39" locator="61:36-61:46" name="EventTiming"/>
      </def>
      <def localId="42" locator="62:1-62:36" name="NOON" id="NOON" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="42">
               <a:s>// Late Morning	Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;NOON&quot;: 'NOON' from </a:s>
               <a:s r="41">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="41" locator="62:26-62:36" name="EventTiming"/>
      </def>
      <def localId="44" locator="63:1-63:34" name="AFT" id="AFT" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="44">
               <a:s>//	Noon	Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;AFT&quot;: 'AFT' from </a:s>
               <a:s r="43">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="43" locator="63:24-63:34" name="EventTiming"/>
      </def>
      <def localId="46" locator="64:1-64:46" name="AFT.early" id="AFT.early" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="46">
               <a:s>//	Afternoon	Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;AFT.early&quot;: 'AFT.early' from </a:s>
               <a:s r="45">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="45" locator="64:36-64:46" name="EventTiming"/>
      </def>
      <def localId="48" locator="65:1-65:44" name="AFT.late" id="AFT.late" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="48">
               <a:s>//	Early Afternoon	Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;AFT.late&quot;: 'AFT.late' from </a:s>
               <a:s r="47">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="47" locator="65:34-65:44" name="EventTiming"/>
      </def>
      <def localId="50" locator="66:1-66:34" name="EVE" id="EVE" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="50">
               <a:s>//	Late Afternoon	Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;EVE&quot;: 'EVE' from </a:s>
               <a:s r="49">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="49" locator="66:24-66:34" name="EventTiming"/>
      </def>
      <def localId="52" locator="67:1-67:46" name="EVE.early" id="EVE.early" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="52">
               <a:s>//	Evening	Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;EVE.early&quot;: 'EVE.early' from </a:s>
               <a:s r="51">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="51" locator="67:36-67:46" name="EventTiming"/>
      </def>
      <def localId="54" locator="68:1-68:44" name="EVE.late" id="EVE.late" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="54">
               <a:s>//	Early Evening	Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;EVE.late&quot;: 'EVE.late' from </a:s>
               <a:s r="53">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="53" locator="68:34-68:44" name="EventTiming"/>
      </def>
      <def localId="56" locator="69:1-69:38" name="NIGHT" id="NIGHT" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="56">
               <a:s>//	Late Evening	Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;NIGHT&quot;: 'NIGHT' from </a:s>
               <a:s r="55">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="55" locator="69:28-69:38" name="EventTiming"/>
      </def>
      <def localId="58" locator="70:1-70:34" name="PHS" id="PHS" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="58">
               <a:s>//	Night	Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;PHS&quot;: 'PHS' from </a:s>
               <a:s r="57">
                  <a:s>EventTiming</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="57" locator="70:24-70:34" name="EventTiming"/>
      </def>
      <def localId="60" locator="72:1-72:130" name="Every eight hours (qualifier value)" id="307469008" display="Every eight hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="60">
               <a:s>//	After Sleep	Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation.
code &quot;Every eight hours (qualifier value)&quot;: '307469008' from </a:s>
               <a:s r="59">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every eight hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="59" locator="72:62-72:84" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="62" locator="73:1-73:150" name="Every eight to twelve hours (qualifier value)" id="396140003" display="Every eight to twelve hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="62">
               <a:s>code &quot;Every eight to twelve hours (qualifier value)&quot;: '396140003' from </a:s>
               <a:s r="61">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every eight to twelve hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="61" locator="73:72-73:94" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="64" locator="74:1-74:142" name="Every forty eight hours (qualifier value)" id="396131002" display="Every forty eight hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="64">
               <a:s>code &quot;Every forty eight hours (qualifier value)&quot;: '396131002' from </a:s>
               <a:s r="63">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every forty eight hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="63" locator="74:68-74:90" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="66" locator="75:1-75:130" name="Every forty hours (qualifier value)" id="396130001" display="Every forty hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="66">
               <a:s>code &quot;Every forty hours (qualifier value)&quot;: '396130001' from </a:s>
               <a:s r="65">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every forty hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="65" locator="75:62-75:84" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="68" locator="76:1-76:128" name="Every four hours (qualifier value)" id="225756002" display="Every four hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="68">
               <a:s>code &quot;Every four hours (qualifier value)&quot;: '225756002' from </a:s>
               <a:s r="67">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every four hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="67" locator="76:61-76:83" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="70" locator="77:1-77:142" name="Every seventy two hours (qualifier value)" id="396143001" display="Every seventy two hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="70">
               <a:s>code &quot;Every seventy two hours (qualifier value)&quot;: '396143001' from </a:s>
               <a:s r="69">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every seventy two hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="69" locator="77:68-77:90" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="72" locator="78:1-78:126" name="Every six hours (qualifier value)" id="307468000" display="Every six hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="72">
               <a:s>code &quot;Every six hours (qualifier value)&quot;: '307468000' from </a:s>
               <a:s r="71">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every six hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="71" locator="78:60-78:82" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="74" locator="79:1-79:144" name="Every six to eight hours (qualifier value)" id="396139000" display="Every six to eight hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="74">
               <a:s>code &quot;Every six to eight hours (qualifier value)&quot;: '396139000' from </a:s>
               <a:s r="73">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every six to eight hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="73" locator="79:69-79:91" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="76" locator="80:1-80:140" name="Every thirty six hours (qualifier value)" id="396126004" display="Every thirty six hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="76">
               <a:s>code &quot;Every thirty six hours (qualifier value)&quot;: '396126004' from </a:s>
               <a:s r="75">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every thirty six hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="75" locator="80:67-80:89" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="78" locator="81:1-81:146" name="Every three to four hours (qualifier value)" id="225754004" display="Every three to four hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="78">
               <a:s>code &quot;Every three to four hours (qualifier value)&quot;: '225754004' from </a:s>
               <a:s r="77">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every three to four hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="77" locator="81:70-81:92" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="80" locator="82:1-82:144" name="Every three to six hours (qualifier value)" id="396127008" display="Every three to six hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="80">
               <a:s>code &quot;Every three to six hours (qualifier value)&quot;: '396127008' from </a:s>
               <a:s r="79">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every three to six hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="79" locator="82:69-82:91" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="82" locator="83:1-83:132" name="Every twelve hours (qualifier value)" id="307470009" display="Every twelve hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="82">
               <a:s>code &quot;Every twelve hours (qualifier value)&quot;: '307470009' from </a:s>
               <a:s r="81">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every twelve hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="81" locator="83:63-83:85" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="84" locator="84:1-84:142" name="Every twenty four hours (qualifier value)" id="396125000" display="Every twenty four hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="84">
               <a:s>code &quot;Every twenty four hours (qualifier value)&quot;: '396125000' from </a:s>
               <a:s r="83">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every twenty four hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="83" locator="84:68-84:90" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="86" locator="85:1-85:142" name="Every two to four hours (qualifier value)" id="225752000" display="Every two to four hours (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="86">
               <a:s>code &quot;Every two to four hours (qualifier value)&quot;: '225752000' from </a:s>
               <a:s r="85">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Every two to four hours (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="85" locator="85:68-85:90" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="88" locator="86:1-86:128" name="Four times daily (qualifier value)" id="307439001" display="Four times daily (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="88">
               <a:s>code &quot;Four times daily (qualifier value)&quot;: '307439001' from </a:s>
               <a:s r="87">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Four times daily (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="87" locator="86:61-86:83" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="90" locator="87:1-87:116" name="Once daily (qualifier value)" id="229797004" display="Once daily (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="90">
               <a:s>code &quot;Once daily (qualifier value)&quot;: '229797004' from </a:s>
               <a:s r="89">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Once daily (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="89" locator="87:55-87:77" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="92" locator="88:1-88:142" name="One to four times a day (qualifier value)" id="396109005" display="One to four times a day (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="92">
               <a:s>code &quot;One to four times a day (qualifier value)&quot;: '396109005' from </a:s>
               <a:s r="91">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'One to four times a day (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="91" locator="88:68-88:90" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="94" locator="89:1-89:144" name="One to three times a day (qualifier value)" id="396108002" display="One to three times a day (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="94">
               <a:s>code &quot;One to three times a day (qualifier value)&quot;: '396108002' from </a:s>
               <a:s r="93">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'One to three times a day (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="93" locator="89:69-89:91" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="96" locator="90:1-90:140" name="One to two times a day (qualifier value)" id="396107007" display="One to two times a day (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="96">
               <a:s>code &quot;One to two times a day (qualifier value)&quot;: '396107007' from </a:s>
               <a:s r="95">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'One to two times a day (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="95" locator="90:67-90:89" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="98" locator="91:1-91:130" name="Three times daily (qualifier value)" id="229798009" display="Three times daily (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="98">
               <a:s>code &quot;Three times daily (qualifier value)&quot;: '229798009' from </a:s>
               <a:s r="97">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Three times daily (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="97" locator="91:62-91:84" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="100" locator="92:1-92:118" name="Twice a day (qualifier value)" id="229799001" display="Twice a day (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="100">
               <a:s>code &quot;Twice a day (qualifier value)&quot;: '229799001' from </a:s>
               <a:s r="99">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Twice a day (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="99" locator="92:56-92:78" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
      <def localId="102" locator="93:1-93:142" name="Two to four times a day (qualifier value)" id="396111001" display="Two to four times a day (qualifier value)" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="102">
               <a:s>code &quot;Two to four times a day (qualifier value)&quot;: '396111001' from </a:s>
               <a:s r="101">
                  <a:s>USCoreCommon.&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Two to four times a day (qualifier value)'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="101" locator="93:68-93:90" name="SNOMEDCT" libraryName="USCoreCommon"/>
      </def>
   </codes>
   <contexts>
      <def locator="97:1-97:15" name="Patient"/>
   </contexts>
   <statements>
      <def locator="97:1-97:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="97:1-97:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="348" locator="118:1-142:5" name="ToDaily" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="348">
               <a:s>/*
 Goal is to get to number of days
 Two broad approaches to the calculation:
  1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered
  2) Based on relevant period, determine a covered interval and calculate the length of that interval in days

This topic covers several use cases and illustrates how to calculate Cumulative
Medication Duration for each type of medication resource using the supply and
frequency approach.
*/

/*
  For the first approach, we need to get from frequency to a frequency/day
  So we define ToDaily
*/

/*
  Calculates daily frequency given frequency within a period
*/
define function ToDaily(frequency </a:s>
               <a:s r="106">
                  <a:s>System.Integer</a:s>
               </a:s>
               <a:s>, period </a:s>
               <a:s r="107">
                  <a:s>System.Quantity</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="347">
                  <a:s r="347">
                     <a:s>case </a:s>
                     <a:s r="109">
                        <a:s r="108">
                           <a:s>period</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="109">
                           <a:s>unit</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="117">
                        <a:s>when </a:s>
                        <a:s r="110">
                           <a:s>'h'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="116">
                           <a:s r="111">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> * </a:s>
                           <a:s r="115">
                              <a:s>(</a:s>
                              <a:s r="115">
                                 <a:s r="112">24.0 / </a:s>
                                 <a:s r="114">
                                    <a:s r="113">
                                       <a:s>period</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="114">
                                       <a:s>value</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="127">
                        <a:s>when </a:s>
                        <a:s r="118">
                           <a:s>'min'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="126">
                           <a:s r="124">
                              <a:s r="119">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="123">
                                 <a:s>(</a:s>
                                 <a:s r="123">
                                    <a:s r="120">24.0 / </a:s>
                                    <a:s r="122">
                                       <a:s r="121">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="122">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="125"> * 60</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="139">
                        <a:s>when </a:s>
                        <a:s r="128">
                           <a:s>'s'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="138">
                           <a:s r="136">
                              <a:s r="134">
                                 <a:s r="129">
                                    <a:s>frequency</a:s>
                                 </a:s>
                                 <a:s> * </a:s>
                                 <a:s r="133">
                                    <a:s>(</a:s>
                                    <a:s r="133">
                                       <a:s r="130">24.0 / </a:s>
                                       <a:s r="132">
                                          <a:s r="131">
                                             <a:s>period</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="132">
                                             <a:s>value</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="135"> * 60</a:s>
                           </a:s>
                           <a:s r="137"> * 60</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="149">
                        <a:s>when </a:s>
                        <a:s r="140">
                           <a:s>'d'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="148">
                           <a:s r="146">
                              <a:s r="141">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="145">
                                 <a:s>(</a:s>
                                 <a:s r="145">
                                    <a:s r="142">24.0 / </a:s>
                                    <a:s r="144">
                                       <a:s r="143">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="144">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="147"> / 24</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="161">
                        <a:s>when </a:s>
                        <a:s r="150">
                           <a:s>'wk'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="160">
                           <a:s r="156">
                              <a:s r="151">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="155">
                                 <a:s>(</a:s>
                                 <a:s r="155">
                                    <a:s r="152">24.0 / </a:s>
                                    <a:s r="154">
                                       <a:s r="153">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="154">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="159">
                              <a:s>(</a:s>
                              <a:s r="159">
                                 <a:s r="157">24 * 7</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="173">
                        <a:s>when </a:s>
                        <a:s r="162">
                           <a:s>'mo'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="172">
                           <a:s r="168">
                              <a:s r="163">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="167">
                                 <a:s>(</a:s>
                                 <a:s r="167">
                                    <a:s r="164">24.0 / </a:s>
                                    <a:s r="166">
                                       <a:s r="165">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="166">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="171">
                              <a:s>(</a:s>
                              <a:s r="171">
                                 <a:s r="169">24 * 30</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s> /* assuming 30 days in month */
    </a:s>
                     <a:s r="185">
                        <a:s>when </a:s>
                        <a:s r="174">
                           <a:s>'a'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="184">
                           <a:s r="180">
                              <a:s r="175">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="179">
                                 <a:s>(</a:s>
                                 <a:s r="179">
                                    <a:s r="176">24.0 / </a:s>
                                    <a:s r="178">
                                       <a:s r="177">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="178">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="183">
                              <a:s>(</a:s>
                              <a:s r="183">
                                 <a:s r="181">24 * 365</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s> /* assuming 365 days in year */
    </a:s>
                     <a:s r="193">
                        <a:s>when </a:s>
                        <a:s r="186">
                           <a:s>'hour'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="192">
                           <a:s r="187">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> * </a:s>
                           <a:s r="191">
                              <a:s>(</a:s>
                              <a:s r="191">
                                 <a:s r="188">24.0 / </a:s>
                                 <a:s r="190">
                                    <a:s r="189">
                                       <a:s>period</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="190">
                                       <a:s>value</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="203">
                        <a:s>when </a:s>
                        <a:s r="194">
                           <a:s>'minute'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="202">
                           <a:s r="200">
                              <a:s r="195">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="199">
                                 <a:s>(</a:s>
                                 <a:s r="199">
                                    <a:s r="196">24.0 / </a:s>
                                    <a:s r="198">
                                       <a:s r="197">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="198">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="201"> * 60</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="215">
                        <a:s>when </a:s>
                        <a:s r="204">
                           <a:s>'second'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="214">
                           <a:s r="212">
                              <a:s r="210">
                                 <a:s r="205">
                                    <a:s>frequency</a:s>
                                 </a:s>
                                 <a:s> * </a:s>
                                 <a:s r="209">
                                    <a:s>(</a:s>
                                    <a:s r="209">
                                       <a:s r="206">24.0 / </a:s>
                                       <a:s r="208">
                                          <a:s r="207">
                                             <a:s>period</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="208">
                                             <a:s>value</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="211"> * 60</a:s>
                           </a:s>
                           <a:s r="213"> * 60</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="225">
                        <a:s>when </a:s>
                        <a:s r="216">
                           <a:s>'day'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="224">
                           <a:s r="222">
                              <a:s r="217">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="221">
                                 <a:s>(</a:s>
                                 <a:s r="221">
                                    <a:s r="218">24.0 / </a:s>
                                    <a:s r="220">
                                       <a:s r="219">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="220">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="223"> / 24</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="237">
                        <a:s>when </a:s>
                        <a:s r="226">
                           <a:s>'week'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="236">
                           <a:s r="232">
                              <a:s r="227">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="231">
                                 <a:s>(</a:s>
                                 <a:s r="231">
                                    <a:s r="228">24.0 / </a:s>
                                    <a:s r="230">
                                       <a:s r="229">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="230">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="235">
                              <a:s>(</a:s>
                              <a:s r="235">
                                 <a:s r="233">24 * 7</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="249">
                        <a:s>when </a:s>
                        <a:s r="238">
                           <a:s>'month'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="248">
                           <a:s r="244">
                              <a:s r="239">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="243">
                                 <a:s>(</a:s>
                                 <a:s r="243">
                                    <a:s r="240">24.0 / </a:s>
                                    <a:s r="242">
                                       <a:s r="241">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="242">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="247">
                              <a:s>(</a:s>
                              <a:s r="247">
                                 <a:s r="245">24 * 30</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s> /* assuming 30 days in month */
    </a:s>
                     <a:s r="261">
                        <a:s>when </a:s>
                        <a:s r="250">
                           <a:s>'year'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="260">
                           <a:s r="256">
                              <a:s r="251">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="255">
                                 <a:s>(</a:s>
                                 <a:s r="255">
                                    <a:s r="252">24.0 / </a:s>
                                    <a:s r="254">
                                       <a:s r="253">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="254">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="259">
                              <a:s>(</a:s>
                              <a:s r="259">
                                 <a:s r="257">24 * 365</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s> /* assuming 365 days in year */
    </a:s>
                     <a:s r="269">
                        <a:s>when </a:s>
                        <a:s r="262">
                           <a:s>'hours'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="268">
                           <a:s r="263">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> * </a:s>
                           <a:s r="267">
                              <a:s>(</a:s>
                              <a:s r="267">
                                 <a:s r="264">24.0 / </a:s>
                                 <a:s r="266">
                                    <a:s r="265">
                                       <a:s>period</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="266">
                                       <a:s>value</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="279">
                        <a:s>when </a:s>
                        <a:s r="270">
                           <a:s>'minutes'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="278">
                           <a:s r="276">
                              <a:s r="271">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="275">
                                 <a:s>(</a:s>
                                 <a:s r="275">
                                    <a:s r="272">24.0 / </a:s>
                                    <a:s r="274">
                                       <a:s r="273">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="274">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="277"> * 60</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="291">
                        <a:s>when </a:s>
                        <a:s r="280">
                           <a:s>'seconds'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="290">
                           <a:s r="288">
                              <a:s r="286">
                                 <a:s r="281">
                                    <a:s>frequency</a:s>
                                 </a:s>
                                 <a:s> * </a:s>
                                 <a:s r="285">
                                    <a:s>(</a:s>
                                    <a:s r="285">
                                       <a:s r="282">24.0 / </a:s>
                                       <a:s r="284">
                                          <a:s r="283">
                                             <a:s>period</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="284">
                                             <a:s>value</a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="287"> * 60</a:s>
                           </a:s>
                           <a:s r="289"> * 60</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="301">
                        <a:s>when </a:s>
                        <a:s r="292">
                           <a:s>'days'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="300">
                           <a:s r="298">
                              <a:s r="293">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="297">
                                 <a:s>(</a:s>
                                 <a:s r="297">
                                    <a:s r="294">24.0 / </a:s>
                                    <a:s r="296">
                                       <a:s r="295">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="296">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="299"> / 24</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="313">
                        <a:s>when </a:s>
                        <a:s r="302">
                           <a:s>'weeks'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="312">
                           <a:s r="308">
                              <a:s r="303">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="307">
                                 <a:s>(</a:s>
                                 <a:s r="307">
                                    <a:s r="304">24.0 / </a:s>
                                    <a:s r="306">
                                       <a:s r="305">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="306">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="311">
                              <a:s>(</a:s>
                              <a:s r="311">
                                 <a:s r="309">24 * 7</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="325">
                        <a:s>when </a:s>
                        <a:s r="314">
                           <a:s>'months'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="324">
                           <a:s r="320">
                              <a:s r="315">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="319">
                                 <a:s>(</a:s>
                                 <a:s r="319">
                                    <a:s r="316">24.0 / </a:s>
                                    <a:s r="318">
                                       <a:s r="317">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="318">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="323">
                              <a:s>(</a:s>
                              <a:s r="323">
                                 <a:s r="321">24 * 30</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s> /* assuming 30 days in month */
    </a:s>
                     <a:s r="337">
                        <a:s>when </a:s>
                        <a:s r="326">
                           <a:s>'years'</a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="336">
                           <a:s r="332">
                              <a:s r="327">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="331">
                                 <a:s>(</a:s>
                                 <a:s r="331">
                                    <a:s r="328">24.0 / </a:s>
                                    <a:s r="330">
                                       <a:s r="329">
                                          <a:s>period</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="330">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> / </a:s>
                           <a:s r="335">
                              <a:s>(</a:s>
                              <a:s r="335">
                                 <a:s r="333">24 * 365</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s> /* assuming 365 days in year */
    else </a:s>
                     <a:s r="346">
                        <a:s r="338">Message(null, true, </a:s>
                        <a:s r="340">
                           <a:s>'CMDLogic.ToDaily.UnknownUnit'</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="341">
                           <a:s>ErrorLevel</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="345">
                           <a:s r="342">
                              <a:s>'Unknown unit '</a:s>
                           </a:s>
                           <a:s> &amp; </a:s>
                           <a:s r="344">
                              <a:s r="343">
                                 <a:s>period</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="344">
                                 <a:s>unit</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>
  end</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="347" locator="119:3-142:5" xsi:type="Case">
            <comparand localId="109" locator="119:8-119:18" path="unit" xsi:type="Property">
               <source localId="108" locator="119:8-119:13" name="period" xsi:type="OperandRef"/>
            </comparand>
            <caseItem localId="117" locator="120:5-120:51">
               <when localId="110" locator="120:10-120:12" valueType="t:String" value="h" xsi:type="Literal"/>
               <then localId="116" locator="120:19-120:51" xsi:type="Multiply">
                  <operand xsi:type="ToDecimal">
                     <operand localId="111" locator="120:19-120:27" name="frequency" xsi:type="OperandRef"/>
                  </operand>
                  <operand localId="115" locator="120:31-120:51" xsi:type="Divide">
                     <operand localId="112" locator="120:32-120:35" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                     <operand localId="114" locator="120:39-120:50" path="value" xsi:type="Property">
                        <source localId="113" locator="120:39-120:44" name="period" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="127" locator="121:5-121:58">
               <when localId="118" locator="121:10-121:14" valueType="t:String" value="min" xsi:type="Literal"/>
               <then localId="126" locator="121:21-121:58" xsi:type="Multiply">
                  <operand localId="124" locator="121:21-121:53" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="119" locator="121:21-121:29" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="123" locator="121:33-121:53" xsi:type="Divide">
                        <operand localId="120" locator="121:34-121:37" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="122" locator="121:41-121:52" path="value" xsi:type="Property">
                           <source localId="121" locator="121:41-121:46" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="125" locator="121:57-121:58" valueType="t:Integer" value="60" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="139" locator="122:5-122:61">
               <when localId="128" locator="122:10-122:12" valueType="t:String" value="s" xsi:type="Literal"/>
               <then localId="138" locator="122:19-122:61" xsi:type="Multiply">
                  <operand localId="136" locator="122:19-122:56" xsi:type="Multiply">
                     <operand localId="134" locator="122:19-122:51" xsi:type="Multiply">
                        <operand xsi:type="ToDecimal">
                           <operand localId="129" locator="122:19-122:27" name="frequency" xsi:type="OperandRef"/>
                        </operand>
                        <operand localId="133" locator="122:31-122:51" xsi:type="Divide">
                           <operand localId="130" locator="122:32-122:35" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                           <operand localId="132" locator="122:39-122:50" path="value" xsi:type="Property">
                              <source localId="131" locator="122:39-122:44" name="period" xsi:type="OperandRef"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand xsi:type="ToDecimal">
                        <operand localId="135" locator="122:55-122:56" valueType="t:Integer" value="60" xsi:type="Literal"/>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="137" locator="122:60-122:61" valueType="t:Integer" value="60" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="149" locator="123:5-123:56">
               <when localId="140" locator="123:10-123:12" valueType="t:String" value="d" xsi:type="Literal"/>
               <then localId="148" locator="123:19-123:56" xsi:type="Divide">
                  <operand localId="146" locator="123:19-123:51" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="141" locator="123:19-123:27" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="145" locator="123:31-123:51" xsi:type="Divide">
                        <operand localId="142" locator="123:32-123:35" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="144" locator="123:39-123:50" path="value" xsi:type="Property">
                           <source localId="143" locator="123:39-123:44" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="147" locator="123:55-123:56" valueType="t:Integer" value="24" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="161" locator="124:5-124:63">
               <when localId="150" locator="124:10-124:13" valueType="t:String" value="wk" xsi:type="Literal"/>
               <then localId="160" locator="124:20-124:63" xsi:type="Divide">
                  <operand localId="156" locator="124:20-124:52" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="151" locator="124:20-124:28" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="155" locator="124:32-124:52" xsi:type="Divide">
                        <operand localId="152" locator="124:33-124:36" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="154" locator="124:40-124:51" path="value" xsi:type="Property">
                           <source localId="153" locator="124:40-124:45" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="159" locator="124:56-124:63" xsi:type="Multiply">
                        <operand localId="157" locator="124:57-124:58" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="158" locator="124:62" valueType="t:Integer" value="7" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="173" locator="125:5-125:64">
               <when localId="162" locator="125:10-125:13" valueType="t:String" value="mo" xsi:type="Literal"/>
               <then localId="172" locator="125:20-125:64" xsi:type="Divide">
                  <operand localId="168" locator="125:20-125:52" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="163" locator="125:20-125:28" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="167" locator="125:32-125:52" xsi:type="Divide">
                        <operand localId="164" locator="125:33-125:36" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="166" locator="125:40-125:51" path="value" xsi:type="Property">
                           <source localId="165" locator="125:40-125:45" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="171" locator="125:56-125:64" xsi:type="Multiply">
                        <operand localId="169" locator="125:57-125:58" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="170" locator="125:62-125:63" valueType="t:Integer" value="30" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="185" locator="126:5-126:64">
               <when localId="174" locator="126:10-126:12" valueType="t:String" value="a" xsi:type="Literal"/>
               <then localId="184" locator="126:19-126:64" xsi:type="Divide">
                  <operand localId="180" locator="126:19-126:51" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="175" locator="126:19-126:27" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="179" locator="126:31-126:51" xsi:type="Divide">
                        <operand localId="176" locator="126:32-126:35" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="178" locator="126:39-126:50" path="value" xsi:type="Property">
                           <source localId="177" locator="126:39-126:44" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="183" locator="126:55-126:64" xsi:type="Multiply">
                        <operand localId="181" locator="126:56-126:57" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="182" locator="126:61-126:63" valueType="t:Integer" value="365" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="193" locator="127:5-127:54">
               <when localId="186" locator="127:10-127:15" valueType="t:String" value="hour" xsi:type="Literal"/>
               <then localId="192" locator="127:22-127:54" xsi:type="Multiply">
                  <operand xsi:type="ToDecimal">
                     <operand localId="187" locator="127:22-127:30" name="frequency" xsi:type="OperandRef"/>
                  </operand>
                  <operand localId="191" locator="127:34-127:54" xsi:type="Divide">
                     <operand localId="188" locator="127:35-127:38" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                     <operand localId="190" locator="127:42-127:53" path="value" xsi:type="Property">
                        <source localId="189" locator="127:42-127:47" name="period" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="203" locator="128:5-128:61">
               <when localId="194" locator="128:10-128:17" valueType="t:String" value="minute" xsi:type="Literal"/>
               <then localId="202" locator="128:24-128:61" xsi:type="Multiply">
                  <operand localId="200" locator="128:24-128:56" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="195" locator="128:24-128:32" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="199" locator="128:36-128:56" xsi:type="Divide">
                        <operand localId="196" locator="128:37-128:40" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="198" locator="128:44-128:55" path="value" xsi:type="Property">
                           <source localId="197" locator="128:44-128:49" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="201" locator="128:60-128:61" valueType="t:Integer" value="60" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="215" locator="129:5-129:66">
               <when localId="204" locator="129:10-129:17" valueType="t:String" value="second" xsi:type="Literal"/>
               <then localId="214" locator="129:24-129:66" xsi:type="Multiply">
                  <operand localId="212" locator="129:24-129:61" xsi:type="Multiply">
                     <operand localId="210" locator="129:24-129:56" xsi:type="Multiply">
                        <operand xsi:type="ToDecimal">
                           <operand localId="205" locator="129:24-129:32" name="frequency" xsi:type="OperandRef"/>
                        </operand>
                        <operand localId="209" locator="129:36-129:56" xsi:type="Divide">
                           <operand localId="206" locator="129:37-129:40" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                           <operand localId="208" locator="129:44-129:55" path="value" xsi:type="Property">
                              <source localId="207" locator="129:44-129:49" name="period" xsi:type="OperandRef"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand xsi:type="ToDecimal">
                        <operand localId="211" locator="129:60-129:61" valueType="t:Integer" value="60" xsi:type="Literal"/>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="213" locator="129:65-129:66" valueType="t:Integer" value="60" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="225" locator="130:5-130:58">
               <when localId="216" locator="130:10-130:14" valueType="t:String" value="day" xsi:type="Literal"/>
               <then localId="224" locator="130:21-130:58" xsi:type="Divide">
                  <operand localId="222" locator="130:21-130:53" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="217" locator="130:21-130:29" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="221" locator="130:33-130:53" xsi:type="Divide">
                        <operand localId="218" locator="130:34-130:37" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="220" locator="130:41-130:52" path="value" xsi:type="Property">
                           <source localId="219" locator="130:41-130:46" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="223" locator="130:57-130:58" valueType="t:Integer" value="24" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="237" locator="131:5-131:65">
               <when localId="226" locator="131:10-131:15" valueType="t:String" value="week" xsi:type="Literal"/>
               <then localId="236" locator="131:22-131:65" xsi:type="Divide">
                  <operand localId="232" locator="131:22-131:54" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="227" locator="131:22-131:30" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="231" locator="131:34-131:54" xsi:type="Divide">
                        <operand localId="228" locator="131:35-131:38" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="230" locator="131:42-131:53" path="value" xsi:type="Property">
                           <source localId="229" locator="131:42-131:47" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="235" locator="131:58-131:65" xsi:type="Multiply">
                        <operand localId="233" locator="131:59-131:60" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="234" locator="131:64" valueType="t:Integer" value="7" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="249" locator="132:5-132:67">
               <when localId="238" locator="132:10-132:16" valueType="t:String" value="month" xsi:type="Literal"/>
               <then localId="248" locator="132:23-132:67" xsi:type="Divide">
                  <operand localId="244" locator="132:23-132:55" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="239" locator="132:23-132:31" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="243" locator="132:35-132:55" xsi:type="Divide">
                        <operand localId="240" locator="132:36-132:39" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="242" locator="132:43-132:54" path="value" xsi:type="Property">
                           <source localId="241" locator="132:43-132:48" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="247" locator="132:59-132:67" xsi:type="Multiply">
                        <operand localId="245" locator="132:60-132:61" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="246" locator="132:65-132:66" valueType="t:Integer" value="30" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="261" locator="133:5-133:67">
               <when localId="250" locator="133:10-133:15" valueType="t:String" value="year" xsi:type="Literal"/>
               <then localId="260" locator="133:22-133:67" xsi:type="Divide">
                  <operand localId="256" locator="133:22-133:54" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="251" locator="133:22-133:30" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="255" locator="133:34-133:54" xsi:type="Divide">
                        <operand localId="252" locator="133:35-133:38" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="254" locator="133:42-133:53" path="value" xsi:type="Property">
                           <source localId="253" locator="133:42-133:47" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="259" locator="133:58-133:67" xsi:type="Multiply">
                        <operand localId="257" locator="133:59-133:60" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="258" locator="133:64-133:66" valueType="t:Integer" value="365" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="269" locator="134:5-134:55">
               <when localId="262" locator="134:10-134:16" valueType="t:String" value="hours" xsi:type="Literal"/>
               <then localId="268" locator="134:23-134:55" xsi:type="Multiply">
                  <operand xsi:type="ToDecimal">
                     <operand localId="263" locator="134:23-134:31" name="frequency" xsi:type="OperandRef"/>
                  </operand>
                  <operand localId="267" locator="134:35-134:55" xsi:type="Divide">
                     <operand localId="264" locator="134:36-134:39" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                     <operand localId="266" locator="134:43-134:54" path="value" xsi:type="Property">
                        <source localId="265" locator="134:43-134:48" name="period" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="279" locator="135:5-135:62">
               <when localId="270" locator="135:10-135:18" valueType="t:String" value="minutes" xsi:type="Literal"/>
               <then localId="278" locator="135:25-135:62" xsi:type="Multiply">
                  <operand localId="276" locator="135:25-135:57" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="271" locator="135:25-135:33" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="275" locator="135:37-135:57" xsi:type="Divide">
                        <operand localId="272" locator="135:38-135:41" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="274" locator="135:45-135:56" path="value" xsi:type="Property">
                           <source localId="273" locator="135:45-135:50" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="277" locator="135:61-135:62" valueType="t:Integer" value="60" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="291" locator="136:5-136:67">
               <when localId="280" locator="136:10-136:18" valueType="t:String" value="seconds" xsi:type="Literal"/>
               <then localId="290" locator="136:25-136:67" xsi:type="Multiply">
                  <operand localId="288" locator="136:25-136:62" xsi:type="Multiply">
                     <operand localId="286" locator="136:25-136:57" xsi:type="Multiply">
                        <operand xsi:type="ToDecimal">
                           <operand localId="281" locator="136:25-136:33" name="frequency" xsi:type="OperandRef"/>
                        </operand>
                        <operand localId="285" locator="136:37-136:57" xsi:type="Divide">
                           <operand localId="282" locator="136:38-136:41" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                           <operand localId="284" locator="136:45-136:56" path="value" xsi:type="Property">
                              <source localId="283" locator="136:45-136:50" name="period" xsi:type="OperandRef"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand xsi:type="ToDecimal">
                        <operand localId="287" locator="136:61-136:62" valueType="t:Integer" value="60" xsi:type="Literal"/>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="289" locator="136:66-136:67" valueType="t:Integer" value="60" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="301" locator="137:5-137:59">
               <when localId="292" locator="137:10-137:15" valueType="t:String" value="days" xsi:type="Literal"/>
               <then localId="300" locator="137:22-137:59" xsi:type="Divide">
                  <operand localId="298" locator="137:22-137:54" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="293" locator="137:22-137:30" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="297" locator="137:34-137:54" xsi:type="Divide">
                        <operand localId="294" locator="137:35-137:38" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="296" locator="137:42-137:53" path="value" xsi:type="Property">
                           <source localId="295" locator="137:42-137:47" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="299" locator="137:58-137:59" valueType="t:Integer" value="24" xsi:type="Literal"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="313" locator="138:5-138:66">
               <when localId="302" locator="138:10-138:16" valueType="t:String" value="weeks" xsi:type="Literal"/>
               <then localId="312" locator="138:23-138:66" xsi:type="Divide">
                  <operand localId="308" locator="138:23-138:55" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="303" locator="138:23-138:31" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="307" locator="138:35-138:55" xsi:type="Divide">
                        <operand localId="304" locator="138:36-138:39" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="306" locator="138:43-138:54" path="value" xsi:type="Property">
                           <source localId="305" locator="138:43-138:48" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="311" locator="138:59-138:66" xsi:type="Multiply">
                        <operand localId="309" locator="138:60-138:61" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="310" locator="138:65" valueType="t:Integer" value="7" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="325" locator="139:5-139:68">
               <when localId="314" locator="139:10-139:17" valueType="t:String" value="months" xsi:type="Literal"/>
               <then localId="324" locator="139:24-139:68" xsi:type="Divide">
                  <operand localId="320" locator="139:24-139:56" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="315" locator="139:24-139:32" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="319" locator="139:36-139:56" xsi:type="Divide">
                        <operand localId="316" locator="139:37-139:40" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="318" locator="139:44-139:55" path="value" xsi:type="Property">
                           <source localId="317" locator="139:44-139:49" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="323" locator="139:60-139:68" xsi:type="Multiply">
                        <operand localId="321" locator="139:61-139:62" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="322" locator="139:66-139:67" valueType="t:Integer" value="30" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="337" locator="140:5-140:68">
               <when localId="326" locator="140:10-140:16" valueType="t:String" value="years" xsi:type="Literal"/>
               <then localId="336" locator="140:23-140:68" xsi:type="Divide">
                  <operand localId="332" locator="140:23-140:55" xsi:type="Multiply">
                     <operand xsi:type="ToDecimal">
                        <operand localId="327" locator="140:23-140:31" name="frequency" xsi:type="OperandRef"/>
                     </operand>
                     <operand localId="331" locator="140:35-140:55" xsi:type="Divide">
                        <operand localId="328" locator="140:36-140:39" valueType="t:Decimal" value="24.0" xsi:type="Literal"/>
                        <operand localId="330" locator="140:43-140:54" path="value" xsi:type="Property">
                           <source localId="329" locator="140:43-140:48" name="period" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="335" locator="140:59-140:68" xsi:type="Multiply">
                        <operand localId="333" locator="140:60-140:61" valueType="t:Integer" value="24" xsi:type="Literal"/>
                        <operand localId="334" locator="140:65-140:67" valueType="t:Integer" value="365" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </then>
            </caseItem>
            <else asType="t:Decimal" xsi:type="As">
               <operand localId="346" locator="141:10-141:103" xsi:type="Message">
                  <source localId="338" locator="141:18-141:21" xsi:type="Null"/>
                  <condition localId="339" locator="141:24-141:27" valueType="t:Boolean" value="true" xsi:type="Literal"/>
                  <code localId="340" locator="141:30-141:59" valueType="t:String" value="CMDLogic.ToDaily.UnknownUnit" xsi:type="Literal"/>
                  <severity localId="341" locator="141:62-141:71" name="ErrorLevel" xsi:type="ParameterRef"/>
                  <message localId="345" locator="141:74-141:102" xsi:type="Concatenate">
                     <operand xsi:type="Coalesce">
                        <operand localId="342" locator="141:74-141:88" valueType="t:String" value="Unknown unit " xsi:type="Literal"/>
                        <operand valueType="t:String" value="" xsi:type="Literal"/>
                     </operand>
                     <operand xsi:type="Coalesce">
                        <operand localId="344" locator="141:92-141:102" path="unit" xsi:type="Property">
                           <source localId="343" locator="141:92-141:97" name="period" xsi:type="OperandRef"/>
                        </operand>
                        <operand valueType="t:String" value="" xsi:type="Literal"/>
                     </operand>
                  </message>
               </operand>
            </else>
         </expression>
         <operand name="frequency">
            <operandTypeSpecifier localId="106" locator="118:35-118:48" name="t:Integer" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="period">
            <operandTypeSpecifier localId="107" locator="118:58-118:72" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="595" locator="150:1-203:5" name="ToDaily" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="595">
               <a:s>/*
  Returns a daily frequency for the given code representation of frequency.
  The function expects codes from the [EventTiming](http://hl7.org/fhir/codesystem-event-timing.html) or
  [V3TimingEvent](http://hl7.org/fhir/v3/TimingEvent/cs.html) code systems.
  // TODO: Determine whether or not we should use timing.code at all....
*/
define function ToDaily(frequency </a:s>
               <a:s r="349">
                  <a:s>Code</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="594">
                  <a:s r="594">
                     <a:s>case
    </a:s>
                     <a:s r="354">
                        <a:s>when </a:s>
                        <a:s r="352">
                           <a:s r="350">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="351">
                              <a:s>&quot;HS&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="353"> then 1</a:s>
                     </a:s>
                     <a:s> // event occurs [offset] before the hour of sleep (or trying to)
    </a:s>
                     <a:s r="359">
                        <a:s>when </a:s>
                        <a:s r="357">
                           <a:s r="355">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="356">
                              <a:s>&quot;WAKE&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="358"> then 1</a:s>
                     </a:s>
                     <a:s> // event occurs [offset] after waking
    </a:s>
                     <a:s r="364">
                        <a:s>when </a:s>
                        <a:s r="362">
                           <a:s r="360">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="361">
                              <a:s>&quot;C&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="363"> then 3</a:s>
                     </a:s>
                     <a:s> //	event occurs at a meal (from the Latin cibus)
    </a:s>
                     <a:s r="369">
                        <a:s>when </a:s>
                        <a:s r="367">
                           <a:s r="365">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="366">
                              <a:s>&quot;CM&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="368"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs at breakfast (from the Latin cibus matutinus)
    </a:s>
                     <a:s r="374">
                        <a:s>when </a:s>
                        <a:s r="372">
                           <a:s r="370">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="371">
                              <a:s>&quot;CD&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="373"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs at lunch (from the Latin cibus diurnus)
    </a:s>
                     <a:s r="379">
                        <a:s>when </a:s>
                        <a:s r="377">
                           <a:s r="375">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="376">
                              <a:s>&quot;CV&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="378"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs at dinner (from the Latin ante cibus vespertinus)
    </a:s>
                     <a:s r="384">
                        <a:s>when </a:s>
                        <a:s r="382">
                           <a:s r="380">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="381">
                              <a:s>&quot;AC&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="383"> then 3</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] before a meal (from the Latin ante cibus)
    </a:s>
                     <a:s r="389">
                        <a:s>when </a:s>
                        <a:s r="387">
                           <a:s r="385">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="386">
                              <a:s>&quot;ACM&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="388"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] before breakfast (from the Latin ante cibus matutinus)
    </a:s>
                     <a:s r="394">
                        <a:s>when </a:s>
                        <a:s r="392">
                           <a:s r="390">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="391">
                              <a:s>&quot;ACD&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="393"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] before lunch (from the Latin ante cibus diurnus)
    </a:s>
                     <a:s r="399">
                        <a:s>when </a:s>
                        <a:s r="397">
                           <a:s r="395">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="396">
                              <a:s>&quot;ACV&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="398"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] before dinner (from the Latin ante cibus vespertinus)
    </a:s>
                     <a:s r="404">
                        <a:s>when </a:s>
                        <a:s r="402">
                           <a:s r="400">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="401">
                              <a:s>&quot;PC&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="403"> then 3</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] after a meal (from the Latin post cibus)
    </a:s>
                     <a:s r="409">
                        <a:s>when </a:s>
                        <a:s r="407">
                           <a:s r="405">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="406">
                              <a:s>&quot;PCM&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="408"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] after breakfast (from the Latin post cibus matutinus)
    </a:s>
                     <a:s r="414">
                        <a:s>when </a:s>
                        <a:s r="412">
                           <a:s r="410">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="411">
                              <a:s>&quot;PCD&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="413"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] after lunch (from the Latin post cibus diurnus)
    </a:s>
                     <a:s r="419">
                        <a:s>when </a:s>
                        <a:s r="417">
                           <a:s r="415">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="416">
                              <a:s>&quot;PCV&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="418"> then 1</a:s>
                     </a:s>
                     <a:s> //	event occurs [offset] after dinner (from the Latin post cibus vespertinus)

    </a:s>
                     <a:s r="424">
                        <a:s>when </a:s>
                        <a:s r="422">
                           <a:s r="420">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="421">
                              <a:s>&quot;MORN&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="423"> then 1</a:s>
                     </a:s>
                     <a:s> //	Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="429">
                        <a:s>when </a:s>
                        <a:s r="427">
                           <a:s r="425">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="426">
                              <a:s>&quot;MORN.early&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="428"> then 1</a:s>
                     </a:s>
                     <a:s> //	Early Morning	Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="434">
                        <a:s>when </a:s>
                        <a:s r="432">
                           <a:s r="430">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="431">
                              <a:s>&quot;MORN.late&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="433"> then 1</a:s>
                     </a:s>
                     <a:s> // Late Morning	Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="439">
                        <a:s>when </a:s>
                        <a:s r="437">
                           <a:s r="435">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="436">
                              <a:s>&quot;NOON&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="438"> then 1</a:s>
                     </a:s>
                     <a:s> //	Noon	Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="444">
                        <a:s>when </a:s>
                        <a:s r="442">
                           <a:s r="440">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="441">
                              <a:s>&quot;AFT&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="443"> then 1</a:s>
                     </a:s>
                     <a:s> //	Afternoon	Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="449">
                        <a:s>when </a:s>
                        <a:s r="447">
                           <a:s r="445">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="446">
                              <a:s>&quot;AFT.early&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="448"> then 1</a:s>
                     </a:s>
                     <a:s> //	Early Afternoon	Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="454">
                        <a:s>when </a:s>
                        <a:s r="452">
                           <a:s r="450">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="451">
                              <a:s>&quot;AFT.late&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="453"> then 1</a:s>
                     </a:s>
                     <a:s> //	Late Afternoon	Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="459">
                        <a:s>when </a:s>
                        <a:s r="457">
                           <a:s r="455">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="456">
                              <a:s>&quot;EVE&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="458"> then 1</a:s>
                     </a:s>
                     <a:s> //	Evening	Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="464">
                        <a:s>when </a:s>
                        <a:s r="462">
                           <a:s r="460">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="461">
                              <a:s>&quot;EVE.early&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="463"> then 1</a:s>
                     </a:s>
                     <a:s> //	Early Evening	Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="469">
                        <a:s>when </a:s>
                        <a:s r="467">
                           <a:s r="465">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="466">
                              <a:s>&quot;EVE.late&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="468"> then 1</a:s>
                     </a:s>
                     <a:s> //	Late Evening	Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="474">
                        <a:s>when </a:s>
                        <a:s r="472">
                           <a:s r="470">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="471">
                              <a:s>&quot;NIGHT&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="473"> then 1</a:s>
                     </a:s>
                     <a:s> //	Night	Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation.
    </a:s>
                     <a:s r="479">
                        <a:s>when </a:s>
                        <a:s r="477">
                           <a:s r="475">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="476">
                              <a:s>&quot;PHS&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="478"> then 1</a:s>
                     </a:s>
                     <a:s> //	After Sleep	Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation.

    </a:s>
                     <a:s r="484">
                        <a:s>when </a:s>
                        <a:s r="482">
                           <a:s r="480">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="481">
                              <a:s>&quot;Once daily (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="483"> then 1.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="489">
                        <a:s>when </a:s>
                        <a:s r="487">
                           <a:s r="485">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="486">
                              <a:s>&quot;Twice a day (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="488"> then 2.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="494">
                        <a:s>when </a:s>
                        <a:s r="492">
                           <a:s r="490">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="491">
                              <a:s>&quot;Three times daily (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="493"> then 3.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="499">
                        <a:s>when </a:s>
                        <a:s r="497">
                           <a:s r="495">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="496">
                              <a:s>&quot;Four times daily (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="498"> then 4.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="504">
                        <a:s>when </a:s>
                        <a:s r="502">
                           <a:s r="500">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="501">
                              <a:s>&quot;Every twenty four hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="503"> then 1.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="509">
                        <a:s>when </a:s>
                        <a:s r="507">
                           <a:s r="505">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="506">
                              <a:s>&quot;Every twelve hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="508"> then 2.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="514">
                        <a:s>when </a:s>
                        <a:s r="512">
                           <a:s r="510">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="511">
                              <a:s>&quot;Every thirty six hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="513"> then 0.67</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="519">
                        <a:s>when </a:s>
                        <a:s r="517">
                           <a:s r="515">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="516">
                              <a:s>&quot;Every eight hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="518"> then 3.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="524">
                        <a:s>when </a:s>
                        <a:s r="522">
                           <a:s r="520">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="521">
                              <a:s>&quot;Every four hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="523"> then 6.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="529">
                        <a:s>when </a:s>
                        <a:s r="527">
                           <a:s r="525">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="526">
                              <a:s>&quot;Every six hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="528"> then 4.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="534">
                        <a:s>when </a:s>
                        <a:s r="532">
                           <a:s r="530">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="531">
                              <a:s>&quot;Every seventy two hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="533"> then 0.33</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="539">
                        <a:s>when </a:s>
                        <a:s r="537">
                           <a:s r="535">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="536">
                              <a:s>&quot;Every forty eight hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="538"> then 0.5</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="544">
                        <a:s>when </a:s>
                        <a:s r="542">
                           <a:s r="540">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="541">
                              <a:s>&quot;Every eight to twelve hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="543"> then 3.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="549">
                        <a:s>when </a:s>
                        <a:s r="547">
                           <a:s r="545">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="546">
                              <a:s>&quot;Every six to eight hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="548"> then 4.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="554">
                        <a:s>when </a:s>
                        <a:s r="552">
                           <a:s r="550">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="551">
                              <a:s>&quot;Every three to four hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="553"> then 8.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="559">
                        <a:s>when </a:s>
                        <a:s r="557">
                           <a:s r="555">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="556">
                              <a:s>&quot;Every three to six hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="558"> then 8.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="564">
                        <a:s>when </a:s>
                        <a:s r="562">
                           <a:s r="560">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="561">
                              <a:s>&quot;Every two to four hours (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="563"> then 12.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="569">
                        <a:s>when </a:s>
                        <a:s r="567">
                           <a:s r="565">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="566">
                              <a:s>&quot;One to four times a day (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="568"> then 4.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="574">
                        <a:s>when </a:s>
                        <a:s r="572">
                           <a:s r="570">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="571">
                              <a:s>&quot;One to three times a day (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="573"> then 3.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="579">
                        <a:s>when </a:s>
                        <a:s r="577">
                           <a:s r="575">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="576">
                              <a:s>&quot;One to two times a day (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="578"> then 2.0</a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="584">
                        <a:s>when </a:s>
                        <a:s r="582">
                           <a:s r="580">
                              <a:s>frequency</a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="581">
                              <a:s>&quot;Two to four times a day (qualifier value)&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s r="583"> then 4.0</a:s>
                     </a:s>
                     <a:s>

    else </a:s>
                     <a:s r="593">
                        <a:s r="585">Message(null, true, </a:s>
                        <a:s r="587">
                           <a:s>'CMDLogic.ToDaily.UnknownFrequencyCode'</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="588">
                           <a:s>ErrorLevel</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="592">
                           <a:s r="589">
                              <a:s>'Unknown frequency code '</a:s>
                           </a:s>
                           <a:s> &amp; </a:s>
                           <a:s r="591">
                              <a:s r="590">
                                 <a:s>frequency</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="591">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>
  end</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="594" locator="151:3-203:5" xsi:type="Case">
            <caseItem localId="354" locator="152:5-152:32">
               <when localId="352" locator="152:10-152:25" xsi:type="Equivalent">
                  <operand localId="350" locator="152:10-152:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="351" locator="152:22-152:25" name="HS" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="353" locator="152:32" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="359" locator="153:5-153:34">
               <when localId="357" locator="153:10-153:27" xsi:type="Equivalent">
                  <operand localId="355" locator="153:10-153:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="356" locator="153:22-153:27" name="WAKE" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="358" locator="153:34" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="364" locator="154:5-154:31">
               <when localId="362" locator="154:10-154:24" xsi:type="Equivalent">
                  <operand localId="360" locator="154:10-154:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="361" locator="154:22-154:24" name="C" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="363" locator="154:31" valueType="t:Integer" value="3" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="369" locator="155:5-155:32">
               <when localId="367" locator="155:10-155:25" xsi:type="Equivalent">
                  <operand localId="365" locator="155:10-155:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="366" locator="155:22-155:25" name="CM" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="368" locator="155:32" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="374" locator="156:5-156:32">
               <when localId="372" locator="156:10-156:25" xsi:type="Equivalent">
                  <operand localId="370" locator="156:10-156:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="371" locator="156:22-156:25" name="CD" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="373" locator="156:32" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="379" locator="157:5-157:32">
               <when localId="377" locator="157:10-157:25" xsi:type="Equivalent">
                  <operand localId="375" locator="157:10-157:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="376" locator="157:22-157:25" name="CV" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="378" locator="157:32" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="384" locator="158:5-158:32">
               <when localId="382" locator="158:10-158:25" xsi:type="Equivalent">
                  <operand localId="380" locator="158:10-158:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="381" locator="158:22-158:25" name="AC" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="383" locator="158:32" valueType="t:Integer" value="3" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="389" locator="159:5-159:33">
               <when localId="387" locator="159:10-159:26" xsi:type="Equivalent">
                  <operand localId="385" locator="159:10-159:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="386" locator="159:22-159:26" name="ACM" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="388" locator="159:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="394" locator="160:5-160:33">
               <when localId="392" locator="160:10-160:26" xsi:type="Equivalent">
                  <operand localId="390" locator="160:10-160:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="391" locator="160:22-160:26" name="ACD" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="393" locator="160:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="399" locator="161:5-161:33">
               <when localId="397" locator="161:10-161:26" xsi:type="Equivalent">
                  <operand localId="395" locator="161:10-161:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="396" locator="161:22-161:26" name="ACV" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="398" locator="161:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="404" locator="162:5-162:32">
               <when localId="402" locator="162:10-162:25" xsi:type="Equivalent">
                  <operand localId="400" locator="162:10-162:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="401" locator="162:22-162:25" name="PC" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="403" locator="162:32" valueType="t:Integer" value="3" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="409" locator="163:5-163:33">
               <when localId="407" locator="163:10-163:26" xsi:type="Equivalent">
                  <operand localId="405" locator="163:10-163:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="406" locator="163:22-163:26" name="PCM" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="408" locator="163:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="414" locator="164:5-164:33">
               <when localId="412" locator="164:10-164:26" xsi:type="Equivalent">
                  <operand localId="410" locator="164:10-164:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="411" locator="164:22-164:26" name="PCD" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="413" locator="164:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="419" locator="165:5-165:33">
               <when localId="417" locator="165:10-165:26" xsi:type="Equivalent">
                  <operand localId="415" locator="165:10-165:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="416" locator="165:22-165:26" name="PCV" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="418" locator="165:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="424" locator="167:5-167:34">
               <when localId="422" locator="167:10-167:27" xsi:type="Equivalent">
                  <operand localId="420" locator="167:10-167:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="421" locator="167:22-167:27" name="MORN" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="423" locator="167:34" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="429" locator="168:5-168:40">
               <when localId="427" locator="168:10-168:33" xsi:type="Equivalent">
                  <operand localId="425" locator="168:10-168:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="426" locator="168:22-168:33" name="MORN.early" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="428" locator="168:40" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="434" locator="169:5-169:39">
               <when localId="432" locator="169:10-169:32" xsi:type="Equivalent">
                  <operand localId="430" locator="169:10-169:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="431" locator="169:22-169:32" name="MORN.late" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="433" locator="169:39" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="439" locator="170:5-170:34">
               <when localId="437" locator="170:10-170:27" xsi:type="Equivalent">
                  <operand localId="435" locator="170:10-170:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="436" locator="170:22-170:27" name="NOON" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="438" locator="170:34" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="444" locator="171:5-171:33">
               <when localId="442" locator="171:10-171:26" xsi:type="Equivalent">
                  <operand localId="440" locator="171:10-171:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="441" locator="171:22-171:26" name="AFT" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="443" locator="171:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="449" locator="172:5-172:39">
               <when localId="447" locator="172:10-172:32" xsi:type="Equivalent">
                  <operand localId="445" locator="172:10-172:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="446" locator="172:22-172:32" name="AFT.early" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="448" locator="172:39" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="454" locator="173:5-173:38">
               <when localId="452" locator="173:10-173:31" xsi:type="Equivalent">
                  <operand localId="450" locator="173:10-173:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="451" locator="173:22-173:31" name="AFT.late" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="453" locator="173:38" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="459" locator="174:5-174:33">
               <when localId="457" locator="174:10-174:26" xsi:type="Equivalent">
                  <operand localId="455" locator="174:10-174:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="456" locator="174:22-174:26" name="EVE" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="458" locator="174:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="464" locator="175:5-175:39">
               <when localId="462" locator="175:10-175:32" xsi:type="Equivalent">
                  <operand localId="460" locator="175:10-175:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="461" locator="175:22-175:32" name="EVE.early" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="463" locator="175:39" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="469" locator="176:5-176:38">
               <when localId="467" locator="176:10-176:31" xsi:type="Equivalent">
                  <operand localId="465" locator="176:10-176:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="466" locator="176:22-176:31" name="EVE.late" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="468" locator="176:38" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="474" locator="177:5-177:35">
               <when localId="472" locator="177:10-177:28" xsi:type="Equivalent">
                  <operand localId="470" locator="177:10-177:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="471" locator="177:22-177:28" name="NIGHT" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="473" locator="177:35" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="479" locator="178:5-178:33">
               <when localId="477" locator="178:10-178:26" xsi:type="Equivalent">
                  <operand localId="475" locator="178:10-178:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="476" locator="178:22-178:26" name="PHS" xsi:type="CodeRef"/>
               </when>
               <then xsi:type="ToDecimal">
                  <operand localId="478" locator="178:33" valueType="t:Integer" value="1" xsi:type="Literal"/>
               </then>
            </caseItem>
            <caseItem localId="484" locator="180:5-180:60">
               <when localId="482" locator="180:10-180:51" xsi:type="Equivalent">
                  <operand localId="480" locator="180:10-180:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="481" locator="180:22-180:51" name="Once daily (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="483" locator="180:58-180:60" valueType="t:Decimal" value="1.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="489" locator="181:5-181:61">
               <when localId="487" locator="181:10-181:52" xsi:type="Equivalent">
                  <operand localId="485" locator="181:10-181:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="486" locator="181:22-181:52" name="Twice a day (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="488" locator="181:59-181:61" valueType="t:Decimal" value="2.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="494" locator="182:5-182:67">
               <when localId="492" locator="182:10-182:58" xsi:type="Equivalent">
                  <operand localId="490" locator="182:10-182:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="491" locator="182:22-182:58" name="Three times daily (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="493" locator="182:65-182:67" valueType="t:Decimal" value="3.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="499" locator="183:5-183:66">
               <when localId="497" locator="183:10-183:57" xsi:type="Equivalent">
                  <operand localId="495" locator="183:10-183:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="496" locator="183:22-183:57" name="Four times daily (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="498" locator="183:64-183:66" valueType="t:Decimal" value="4.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="504" locator="184:5-184:73">
               <when localId="502" locator="184:10-184:64" xsi:type="Equivalent">
                  <operand localId="500" locator="184:10-184:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="501" locator="184:22-184:64" name="Every twenty four hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="503" locator="184:71-184:73" valueType="t:Decimal" value="1.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="509" locator="185:5-185:68">
               <when localId="507" locator="185:10-185:59" xsi:type="Equivalent">
                  <operand localId="505" locator="185:10-185:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="506" locator="185:22-185:59" name="Every twelve hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="508" locator="185:66-185:68" valueType="t:Decimal" value="2.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="514" locator="186:5-186:73">
               <when localId="512" locator="186:10-186:63" xsi:type="Equivalent">
                  <operand localId="510" locator="186:10-186:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="511" locator="186:22-186:63" name="Every thirty six hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="513" locator="186:70-186:73" valueType="t:Decimal" value="0.67" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="519" locator="187:5-187:67">
               <when localId="517" locator="187:10-187:58" xsi:type="Equivalent">
                  <operand localId="515" locator="187:10-187:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="516" locator="187:22-187:58" name="Every eight hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="518" locator="187:65-187:67" valueType="t:Decimal" value="3.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="524" locator="188:5-188:66">
               <when localId="522" locator="188:10-188:57" xsi:type="Equivalent">
                  <operand localId="520" locator="188:10-188:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="521" locator="188:22-188:57" name="Every four hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="523" locator="188:64-188:66" valueType="t:Decimal" value="6.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="529" locator="189:5-189:65">
               <when localId="527" locator="189:10-189:56" xsi:type="Equivalent">
                  <operand localId="525" locator="189:10-189:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="526" locator="189:22-189:56" name="Every six hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="528" locator="189:63-189:65" valueType="t:Decimal" value="4.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="534" locator="190:5-190:74">
               <when localId="532" locator="190:10-190:64" xsi:type="Equivalent">
                  <operand localId="530" locator="190:10-190:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="531" locator="190:22-190:64" name="Every seventy two hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="533" locator="190:71-190:74" valueType="t:Decimal" value="0.33" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="539" locator="191:5-191:73">
               <when localId="537" locator="191:10-191:64" xsi:type="Equivalent">
                  <operand localId="535" locator="191:10-191:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="536" locator="191:22-191:64" name="Every forty eight hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="538" locator="191:71-191:73" valueType="t:Decimal" value="0.5" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="544" locator="192:5-192:77">
               <when localId="542" locator="192:10-192:68" xsi:type="Equivalent">
                  <operand localId="540" locator="192:10-192:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="541" locator="192:22-192:68" name="Every eight to twelve hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="543" locator="192:75-192:77" valueType="t:Decimal" value="3.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="549" locator="193:5-193:74">
               <when localId="547" locator="193:10-193:65" xsi:type="Equivalent">
                  <operand localId="545" locator="193:10-193:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="546" locator="193:22-193:65" name="Every six to eight hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="548" locator="193:72-193:74" valueType="t:Decimal" value="4.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="554" locator="194:5-194:75">
               <when localId="552" locator="194:10-194:66" xsi:type="Equivalent">
                  <operand localId="550" locator="194:10-194:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="551" locator="194:22-194:66" name="Every three to four hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="553" locator="194:73-194:75" valueType="t:Decimal" value="8.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="559" locator="195:5-195:74">
               <when localId="557" locator="195:10-195:65" xsi:type="Equivalent">
                  <operand localId="555" locator="195:10-195:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="556" locator="195:22-195:65" name="Every three to six hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="558" locator="195:72-195:74" valueType="t:Decimal" value="8.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="564" locator="196:5-196:74">
               <when localId="562" locator="196:10-196:64" xsi:type="Equivalent">
                  <operand localId="560" locator="196:10-196:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="561" locator="196:22-196:64" name="Every two to four hours (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="563" locator="196:71-196:74" valueType="t:Decimal" value="12.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="569" locator="197:5-197:73">
               <when localId="567" locator="197:10-197:64" xsi:type="Equivalent">
                  <operand localId="565" locator="197:10-197:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="566" locator="197:22-197:64" name="One to four times a day (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="568" locator="197:71-197:73" valueType="t:Decimal" value="4.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="574" locator="198:5-198:74">
               <when localId="572" locator="198:10-198:65" xsi:type="Equivalent">
                  <operand localId="570" locator="198:10-198:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="571" locator="198:22-198:65" name="One to three times a day (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="573" locator="198:72-198:74" valueType="t:Decimal" value="3.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="579" locator="199:5-199:72">
               <when localId="577" locator="199:10-199:63" xsi:type="Equivalent">
                  <operand localId="575" locator="199:10-199:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="576" locator="199:22-199:63" name="One to two times a day (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="578" locator="199:70-199:72" valueType="t:Decimal" value="2.0" xsi:type="Literal"/>
            </caseItem>
            <caseItem localId="584" locator="200:5-200:73">
               <when localId="582" locator="200:10-200:64" xsi:type="Equivalent">
                  <operand localId="580" locator="200:10-200:18" name="frequency" xsi:type="OperandRef"/>
                  <operand localId="581" locator="200:22-200:64" name="Two to four times a day (qualifier value)" xsi:type="CodeRef"/>
               </when>
               <then localId="583" locator="200:71-200:73" valueType="t:Decimal" value="4.0" xsi:type="Literal"/>
            </caseItem>
            <else asType="t:Decimal" xsi:type="As">
               <operand localId="593" locator="202:10-202:125" xsi:type="Message">
                  <source localId="585" locator="202:18-202:21" xsi:type="Null"/>
                  <condition localId="586" locator="202:24-202:27" valueType="t:Boolean" value="true" xsi:type="Literal"/>
                  <code localId="587" locator="202:30-202:68" valueType="t:String" value="CMDLogic.ToDaily.UnknownFrequencyCode" xsi:type="Literal"/>
                  <severity localId="588" locator="202:71-202:80" name="ErrorLevel" xsi:type="ParameterRef"/>
                  <message localId="592" locator="202:83-202:124" xsi:type="Concatenate">
                     <operand xsi:type="Coalesce">
                        <operand localId="589" locator="202:83-202:107" valueType="t:String" value="Unknown frequency code " xsi:type="Literal"/>
                        <operand valueType="t:String" value="" xsi:type="Literal"/>
                     </operand>
                     <operand xsi:type="Coalesce">
                        <operand localId="591" locator="202:111-202:124" path="code" xsi:type="Property">
                           <source localId="590" locator="202:111-202:119" name="frequency" xsi:type="OperandRef"/>
                        </operand>
                        <operand valueType="t:String" value="" xsi:type="Literal"/>
                     </operand>
                  </message>
               </operand>
            </else>
         </expression>
         <operand name="frequency">
            <operandTypeSpecifier localId="349" locator="150:35-150:38" name="t:Code" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="633" locator="592:1-596:8" name="Quantity" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="633">
               <a:s>/**********************************************************************/
/* Functions in this region are copied from opioid-mme-r4             */
/**********************************************************************/
define function Quantity(value </a:s>
               <a:s r="624">
                  <a:s>Decimal</a:s>
               </a:s>
               <a:s>, unit </a:s>
               <a:s r="625">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="632">
                  <a:s r="632">
                     <a:s>if </a:s>
                     <a:s r="627">
                        <a:s r="626">
                           <a:s>value</a:s>
                        </a:s>
                        <a:s> is not null</a:s>
                     </a:s>
                     <a:s> then
    </a:s>
                     <a:s r="630">
                        <a:s>System.Quantity { </a:s>
                        <a:s>
                           <a:s>value: </a:s>
                           <a:s r="628">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s>
                           <a:s>unit: </a:s>
                           <a:s r="629">
                              <a:s>unit</a:s>
                           </a:s>
                        </a:s>
                        <a:s> }</a:s>
                     </a:s>
                     <a:s r="631">
  else
    null</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="632" locator="593:3-596:8" xsi:type="If">
            <condition localId="627" locator="593:6-593:22" xsi:type="Not">
               <operand locator="593:6-593:22" xsi:type="IsNull">
                  <operand localId="626" locator="593:6-593:10" name="value" xsi:type="OperandRef"/>
               </operand>
            </condition>
            <then localId="630" locator="594:5-594:48" classType="t:Quantity" xsi:type="Instance">
               <element name="value">
                  <value localId="628" locator="594:30-594:34" name="value" xsi:type="OperandRef"/>
               </element>
               <element name="unit">
                  <value localId="629" locator="594:43-594:46" name="unit" xsi:type="OperandRef"/>
               </element>
            </then>
            <else asType="t:Quantity" xsi:type="As">
               <operand localId="631" locator="596:5-596:8" xsi:type="Null"/>
            </else>
         </expression>
         <operand name="value">
            <operandTypeSpecifier localId="624" locator="592:32-592:38" name="t:Decimal" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="unit">
            <operandTypeSpecifier localId="625" locator="592:46-592:51" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="758" locator="284:1-318:13" name="MedicationRequestPeriodTest" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="758">
               <a:s>/*
Now that we have a ToDaily function, we can approach calculation of the
duration of medication for an order. First, consider the definitions
for each element:

* 1 and only 1 dosageInstruction
* 1 and only 1 doseAndRate
* 1 timing with 1 repeat
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* doseQuantity or doseRange
* timeOfDay

* authoredOn: The date the prescription was written
* dispenseRequest.validityPeriod: Time period supply is authorized for
* dispenseRequest.quantity: amount of medication supplied per dispense
* dispenseRequest.numberOfRepeatsAllowed: number of refills authorized
* dispenseRequest.expectedSupplyDuration: number of days supply per dispense
* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat
* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat
* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat
* dosageInstruction.timing.repeat.count: number of times to repeat
* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat
* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period
* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period
* dosageInstruction.timing.repeat.period: event occurs frequency times per period
* dosageInstruction.timing.repeat.periodMax: upper limit of period
* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a)
* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*)
* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...)
* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD...
* dosageInstruction.asNeeded
* dosageInstruction.doseAndRate.doseQuantity
* dosageInstruction.doseAndRate.doseRange

If expectedSupplyDuration is present, then the duration is

    expectedSupplyDuration * (1 + numberOfRepeatsAllowed)

If expectedSupplyDuration is not present, then it must be calculated based on the quantity, dosage, and frequency:

    (quantity / (dosage * frequency)) * (1 + numberOfRepeatsAllowed)

    dosage: Coalesce(end of doseAndRate.doseRange, doseAndRate.doseQuantity)
    frequency: Coalesce(frequencyMax, frequency)
    period: Quantity(period, periodUnit)

If expectedSupplyDuration is not present and cannot be calculated, and the boundsPeriod is present (and completely specified), we can use that directly

    dosage.timing.repeat.boundsPeriod

This calculation results in a number of days, which can then be turned into a period by anchoring that to the
start of the validityPeriod or the authoredOn:

    Interval[earliestDispensable, earliestDispensable + expectedSupplyDuration - 1]

    earliestDispensable: Coalesce(start of validityPeriod, authoredOn)

The following function illustrates this completely:
*/

/*
Calculates the Medication Period for a single MedicationRequest.
MedicationRequest instances provided to this function are expected
to conform to the [MMEMedicationRequest](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationrequest.html)
profile, which expects:
* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error
* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error
* 1 timing with 1 repeat, missing timing or repeat elements will result in a null
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* timeOfDay
* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null
Note that MedicationRequest status is not considered by this calculation, as the
list of MedicationRequest instances provided to this function should already have
considered appropriate statuses, depending on the use case, typically `completed`.

NOTE: Updated return to use &quot;date from end of boundsPeriod&quot; to ensure result is Interval&lt;Date>
*/
define function MedicationRequestPeriodTest(Request </a:s>
               <a:s r="596">
                  <a:s>USCore.&quot;MedicationRequestProfile&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="757">
                  <a:s r="757">
                     <a:s>
                        <a:s r="598">
                           <a:s r="597">
                              <a:s>
                                 <a:s>Request</a:s>
                              </a:s>
                           </a:s>
                           <a:s> R</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s>
                        <a:s>let
      </a:s>
                        <a:s r="602">
                           <a:s>dosage: </a:s>
                           <a:s r="601">
                              <a:s>singleton from </a:s>
                              <a:s r="600">
                                 <a:s r="599">
                                    <a:s>R</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="600">
                                    <a:s>dosageInstruction</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="606">
                           <a:s>doseAndRate: </a:s>
                           <a:s r="605">
                              <a:s>singleton from </a:s>
                              <a:s r="604">
                                 <a:s r="603">
                                    <a:s>dosage</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="604">
                                    <a:s>doseAndRate</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="609">
                           <a:s>timing: </a:s>
                           <a:s r="608">
                              <a:s r="607">
                                 <a:s>dosage</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="608">
                                 <a:s>timing</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="617">
                           <a:s>frequency: </a:s>
                           <a:s r="616">
                              <a:s>Coalesce(</a:s>
                              <a:s r="612">
                                 <a:s r="611">
                                    <a:s r="610">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="611">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="612">
                                    <a:s>frequencyMax</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="615">
                                 <a:s r="614">
                                    <a:s r="613">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="614">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="615">
                                    <a:s>frequency</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="635">
                           <a:s>period: </a:s>
                           <a:s r="634">
                              <a:s>Quantity(</a:s>
                              <a:s r="620">
                                 <a:s r="619">
                                    <a:s r="618">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="619">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="620">
                                    <a:s>period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="623">
                                 <a:s r="622">
                                    <a:s r="621">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="622">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="623">
                                    <a:s>periodUnit</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="638">
                           <a:s>doseRange: </a:s>
                           <a:s r="637">
                              <a:s r="636">
                                 <a:s>doseAndRate</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="637">
                                 <a:s>dose</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="641">
                           <a:s>doseQuantity: </a:s>
                           <a:s r="640">
                              <a:s r="639">
                                 <a:s>doseAndRate</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="640">
                                 <a:s>dose</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="646">
                           <a:s>dose: </a:s>
                           <a:s r="645">
                              <a:s>Coalesce(</a:s>
                              <a:s r="643">
                                 <a:s>end of </a:s>
                                 <a:s r="642">
                                    <a:s>doseRange</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="644">
                                 <a:s>doseQuantity</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="656">
                           <a:s>dosesPerDay: </a:s>
                           <a:s r="655">
                              <a:s>Coalesce(</a:s>
                              <a:s r="649">
                                 <a:s>ToDaily(</a:s>
                                 <a:s r="647">
                                    <a:s>frequency</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="648">
                                    <a:s>period</a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="653">
                                 <a:s>Count(</a:s>
                                 <a:s r="652">
                                    <a:s r="651">
                                       <a:s r="650">
                                          <a:s>timing</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="651">
                                          <a:s>repeat</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="652">
                                       <a:s>timeOfDay</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="654">, 1.0)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="663">
                           <a:s>boundsPeriod: </a:s>
                           <a:s r="662">
                              <a:s r="659">
                                 <a:s r="658">
                                    <a:s r="657">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="658">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="659">
                                    <a:s>bounds</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> as </a:s>
                              <a:s r="661">
                                 <a:s>Interval&lt;</a:s>
                                 <a:s r="660">
                                    <a:s>DateTime</a:s>
                                 </a:s>
                                 <a:s>></a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="668">
                           <a:s>expectedDaysSupply: </a:s>
                           <a:s r="667">
                              <a:s r="666">
                                 <a:s r="665">
                                    <a:s r="664">
                                       <a:s>R</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="665">
                                       <a:s>dispenseRequest</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="666">
                                    <a:s>expectedSupplyDuration</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="667">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      // TODO: this isn't working as expected, convert results in null
      //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value,
      </a:s>
                        <a:s r="673">
                           <a:s>daysSupply: </a:s>
                           <a:s r="672">
                              <a:s r="671">
                                 <a:s>(</a:s>
                                 <a:s r="671">
                                    <a:s r="670">
                                       <a:s r="669">
                                          <a:s>R</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="670">
                                          <a:s>dispenseRequest</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="671">
                                       <a:s>expectedSupplyDuration</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="672">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="677">
                           <a:s>quantity: </a:s>
                           <a:s r="676">
                              <a:s r="675">
                                 <a:s r="674">
                                    <a:s>R</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="675">
                                    <a:s>dispenseRequest</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="676">
                                 <a:s>quantity</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="683">
                           <a:s>refills: </a:s>
                           <a:s r="682">
                              <a:s>Coalesce(</a:s>
                              <a:s r="680">
                                 <a:s r="679">
                                    <a:s r="678">
                                       <a:s>R</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="679">
                                       <a:s>dispenseRequest</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="680">
                                    <a:s>numberOfRepeatsAllowed</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="681">, 0)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="696">
                           <a:s>startDate:
        </a:s>
                           <a:s r="695">
                              <a:s>Coalesce(
          </a:s>
                              <a:s r="686">
                                 <a:s>date from </a:s>
                                 <a:s r="685">
                                    <a:s>start of </a:s>
                                    <a:s r="684">
                                       <a:s>boundsPeriod</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>,
          </a:s>
                              <a:s r="689">
                                 <a:s>date from </a:s>
                                 <a:s r="688">
                                    <a:s r="687">
                                       <a:s>R</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="688">
                                       <a:s>authoredOn</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>,
          </a:s>
                              <a:s r="694">
                                 <a:s>date from </a:s>
                                 <a:s r="693">
                                    <a:s>start of </a:s>
                                    <a:s r="692">
                                       <a:s r="691">
                                          <a:s r="690">
                                             <a:s>R</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="691">
                                             <a:s>dispenseRequest</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="692">
                                          <a:s>validityPeriod</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
        )</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="710">
                           <a:s>totalDaysSupplied: </a:s>
                           <a:s r="709">
                              <a:s r="705">
                                 <a:s>Coalesce(</a:s>
                                 <a:s r="697">
                                    <a:s>daysSupply</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="704">
                                    <a:s r="699">
                                       <a:s r="698">
                                          <a:s>quantity</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="699">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> / </a:s>
                                    <a:s r="703">
                                       <a:s>(</a:s>
                                       <a:s r="703">
                                          <a:s r="701">
                                             <a:s r="700">
                                                <a:s>dose</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="701">
                                                <a:s>value</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> * </a:s>
                                          <a:s r="702">
                                             <a:s>dosesPerDay</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="708">
                                 <a:s>(</a:s>
                                 <a:s r="708">
                                    <a:s r="706">1 + </a:s>
                                    <a:s r="707">
                                       <a:s>refills</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="756">
                        <a:s>return </a:s>
                        <a:s r="755">
                           <a:s>{ </a:s>
                           <a:s>
                              <a:s>dosage: </a:s>
                              <a:s r="711">
                                 <a:s>dosage</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>doseAndRate: </a:s>
                              <a:s r="712">
                                 <a:s>doseAndRate</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>timing: </a:s>
                              <a:s r="713">
                                 <a:s>timing</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>frequency: </a:s>
                              <a:s r="714">
                                 <a:s>frequency</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>period: </a:s>
                              <a:s r="715">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>,
      </a:s>
                           <a:s>
                              <a:s>doseRange: </a:s>
                              <a:s r="716">
                                 <a:s>doseRange</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>doseQuantity: </a:s>
                              <a:s r="717">
                                 <a:s>doseQuantity</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>dose: </a:s>
                              <a:s r="718">
                                 <a:s>dose</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>dosesPerDay: </a:s>
                              <a:s r="719">
                                 <a:s>dosesPerDay</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>boundsPeriod: </a:s>
                              <a:s r="720">
                                 <a:s>boundsPeriod</a:s>
                              </a:s>
                           </a:s>
                           <a:s>,
      </a:s>
                           <a:s>
                              <a:s>expectedDaysSupply: </a:s>
                              <a:s r="721">
                                 <a:s>expectedDaysSupply</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>daysSupply: </a:s>
                              <a:s r="722">
                                 <a:s>daysSupply</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>quantity: </a:s>
                              <a:s r="723">
                                 <a:s>quantity</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>refills: </a:s>
                              <a:s r="724">
                                 <a:s>refills</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>startDate: </a:s>
                              <a:s r="725">
                                 <a:s>startDate</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s>
                              <a:s>totalDaysSupplied: </a:s>
                              <a:s r="726">
                                 <a:s>totalDaysSupplied</a:s>
                              </a:s>
                           </a:s>
                           <a:s>,
      </a:s>
                           <a:s>
                              <a:s>requestPeriod: </a:s>
                              <a:s r="754">
                                 <a:s>if </a:s>
                                 <a:s r="731">
                                    <a:s r="728">
                                       <a:s r="727">
                                          <a:s>startDate</a:s>
                                       </a:s>
                                       <a:s> is not null</a:s>
                                    </a:s>
                                    <a:s> and </a:s>
                                    <a:s r="730">
                                       <a:s r="729">
                                          <a:s>totalDaysSupplied</a:s>
                                       </a:s>
                                       <a:s> is not null</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> then
        </a:s>
                                 <a:s r="740">
                                    <a:s>Interval[</a:s>
                                    <a:s r="732">
                                       <a:s>startDate</a:s>
                                    </a:s>
                                    <a:s>, </a:s>
                                    <a:s r="739">
                                       <a:s r="733">
                                          <a:s>startDate</a:s>
                                       </a:s>
                                       <a:s> + </a:s>
                                       <a:s r="738">
                                          <a:s>Quantity(</a:s>
                                          <a:s r="736">
                                             <a:s r="734">
                                                <a:s>totalDaysSupplied</a:s>
                                             </a:s>
                                             <a:s r="735"> - 1</a:s>
                                          </a:s>
                                          <a:s>, </a:s>
                                          <a:s r="737">
                                             <a:s>'day'</a:s>
                                          </a:s>
                                          <a:s>)</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> ]</a:s>
                                 </a:s>
                                 <a:s>
      else </a:s>
                                 <a:s r="753">
                                    <a:s>if </a:s>
                                    <a:s r="746">
                                       <a:s r="742">
                                          <a:s r="741">
                                             <a:s>startDate</a:s>
                                          </a:s>
                                          <a:s> is not null</a:s>
                                       </a:s>
                                       <a:s> and </a:s>
                                       <a:s r="745">
                                          <a:s r="744">
                                             <a:s r="743">
                                                <a:s>boundsPeriod</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="744">
                                                <a:s>&quot;high&quot;</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> is not null</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> then
        </a:s>
                                    <a:s r="751">
                                       <a:s>Interval[</a:s>
                                       <a:s r="747">
                                          <a:s>startDate</a:s>
                                       </a:s>
                                       <a:s>, </a:s>
                                       <a:s r="750">
                                          <a:s>date from </a:s>
                                          <a:s r="749">
                                             <a:s>end of </a:s>
                                             <a:s r="748">
                                                <a:s>boundsPeriod</a:s>
                                             </a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>]</a:s>
                                    </a:s>
                                    <a:s r="752">
      else
        null</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>}</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="757" locator="285:3-318:13" xsi:type="Query">
            <source localId="598" locator="285:3-285:11" alias="R">
               <expression localId="597" locator="285:3-285:9" name="Request" xsi:type="OperandRef"/>
            </source>
            <let localId="602" locator="287:7-287:48" identifier="dosage">
               <expression localId="601" locator="287:15-287:48" xsi:type="SingletonFrom">
                  <operand localId="600" locator="287:30-287:48" path="dosageInstruction" scope="R" xsi:type="Property"/>
               </expression>
            </let>
            <let localId="606" locator="288:7-288:52" identifier="doseAndRate">
               <expression localId="605" locator="288:20-288:52" xsi:type="SingletonFrom">
                  <operand localId="604" locator="288:35-288:52" path="doseAndRate" xsi:type="Property">
                     <source localId="603" locator="288:35-288:40" name="dosage" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="609" locator="289:7-289:27" identifier="timing">
               <expression localId="608" locator="289:15-289:27" path="timing" xsi:type="Property">
                  <source localId="607" locator="289:15-289:20" name="dosage" xsi:type="QueryLetRef"/>
               </expression>
            </let>
            <let localId="617" locator="290:7-290:78" identifier="frequency">
               <expression localId="616" locator="290:18-290:78" xsi:type="Coalesce">
                  <operand localId="612" locator="290:27-290:52" path="value" xsi:type="Property">
                     <source path="frequencyMax" xsi:type="Property">
                        <source localId="611" locator="290:27-290:39" path="repeat" xsi:type="Property">
                           <source localId="610" locator="290:27-290:32" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
                  <operand localId="615" locator="290:55-290:77" path="value" xsi:type="Property">
                     <source path="frequency" xsi:type="Property">
                        <source localId="614" locator="290:55-290:67" path="repeat" xsi:type="Property">
                           <source localId="613" locator="290:55-290:60" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
               </expression>
            </let>
            <let localId="635" locator="291:7-291:70" identifier="period">
               <expression localId="634" locator="291:15-291:70" name="Quantity" xsi:type="FunctionRef">
                  <operand localId="620" locator="291:24-291:43" path="value" xsi:type="Property">
                     <source path="period" xsi:type="Property">
                        <source localId="619" locator="291:24-291:36" path="repeat" xsi:type="Property">
                           <source localId="618" locator="291:24-291:29" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
                  <operand localId="623" locator="291:46-291:69" path="value" xsi:type="Property">
                     <source path="periodUnit" xsi:type="Property">
                        <source localId="622" locator="291:46-291:58" path="repeat" xsi:type="Property">
                           <source localId="621" locator="291:46-291:51" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
               </expression>
            </let>
            <let localId="638" locator="292:7-292:33" identifier="doseRange">
               <expression localId="637" locator="292:18-292:33" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="dose" xsi:type="Property">
                     <source localId="636" locator="292:18-292:28" name="doseAndRate" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="641" locator="293:7-293:36" identifier="doseQuantity">
               <expression localId="640" locator="293:21-293:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="dose" xsi:type="Property">
                     <source localId="639" locator="293:21-293:31" name="doseAndRate" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="646" locator="294:7-294:52" identifier="dose">
               <expression localId="645" locator="294:13-294:52" xsi:type="Coalesce">
                  <operand localId="643" locator="294:22-294:37" xsi:type="End">
                     <operand xsi:type="As">
                        <operand localId="642" locator="294:29-294:37" name="doseRange" xsi:type="QueryLetRef"/>
                        <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                           <pointType name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        </asTypeSpecifier>
                     </operand>
                  </operand>
                  <operand asType="t:Quantity" xsi:type="As">
                     <operand localId="644" locator="294:40-294:51" name="doseQuantity" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="656" locator="295:7-295:92" identifier="dosesPerDay">
               <expression localId="655" locator="295:20-295:92" xsi:type="Coalesce">
                  <operand localId="649" locator="295:29-295:54" name="ToDaily" xsi:type="FunctionRef">
                     <operand localId="647" locator="295:37-295:45" name="frequency" xsi:type="QueryLetRef"/>
                     <operand localId="648" locator="295:48-295:53" name="period" xsi:type="QueryLetRef"/>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="653" locator="295:57-295:86" xsi:type="Count">
                        <source localId="652" locator="295:63-295:85" path="value" xsi:type="Property">
                           <source path="timeOfDay" xsi:type="Property">
                              <source localId="651" locator="295:63-295:75" path="repeat" xsi:type="Property">
                                 <source localId="650" locator="295:63-295:68" name="timing" xsi:type="QueryLetRef"/>
                              </source>
                           </source>
                        </source>
                     </operand>
                  </operand>
                  <operand localId="654" locator="295:89-295:91" valueType="t:Decimal" value="1.0" xsi:type="Literal"/>
               </expression>
            </let>
            <let localId="663" locator="296:7-296:62" identifier="boundsPeriod">
               <expression localId="662" locator="296:21-296:62" strict="false" xsi:type="As">
                  <operand localId="659" locator="296:21-296:40" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="bounds" xsi:type="Property">
                        <source localId="658" locator="296:21-296:33" path="repeat" xsi:type="Property">
                           <source localId="657" locator="296:21-296:26" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </operand>
                  </operand>
                  <asTypeSpecifier localId="661" locator="296:45-296:62" xsi:type="IntervalTypeSpecifier">
                     <pointType localId="660" locator="296:54-296:61" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                  </asTypeSpecifier>
               </expression>
            </let>
            <let localId="668" locator="297:7-297:72" identifier="expectedDaysSupply">
               <expression localId="667" locator="297:27-297:72" path="value" xsi:type="Property">
                  <source localId="666" locator="297:27-297:66" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="expectedSupplyDuration" xsi:type="Property">
                        <source localId="665" locator="297:27-297:43" path="dispenseRequest" scope="R" xsi:type="Property"/>
                     </operand>
                  </source>
               </expression>
            </let>
            <let localId="673" locator="300:7-300:66" identifier="daysSupply">
               <expression localId="672" locator="300:19-300:66" path="value" xsi:type="Property">
                  <source localId="671" locator="300:19-300:60" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="expectedSupplyDuration" xsi:type="Property">
                        <source localId="670" locator="300:20-300:36" path="dispenseRequest" scope="R" xsi:type="Property"/>
                     </operand>
                  </source>
               </expression>
            </let>
            <let localId="677" locator="301:7-301:42" identifier="quantity">
               <expression localId="676" locator="301:17-301:42" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="quantity" xsi:type="Property">
                     <source localId="675" locator="301:17-301:33" path="dispenseRequest" scope="R" xsi:type="Property"/>
                  </operand>
               </expression>
            </let>
            <let localId="683" locator="302:7-302:68" identifier="refills">
               <expression localId="682" locator="302:16-302:68" xsi:type="Coalesce">
                  <operand localId="680" locator="302:25-302:64" path="value" xsi:type="Property">
                     <source path="numberOfRepeatsAllowed" xsi:type="Property">
                        <source localId="679" locator="302:25-302:41" path="dispenseRequest" scope="R" xsi:type="Property"/>
                     </source>
                  </operand>
                  <operand localId="681" locator="302:67" valueType="t:Integer" value="0" xsi:type="Literal"/>
               </expression>
            </let>
            <let localId="696" locator="303:7-308:9" identifier="startDate">
               <expression localId="695" locator="304:9-308:9" xsi:type="Coalesce">
                  <operand localId="686" locator="305:11-305:41" xsi:type="DateFrom">
                     <operand localId="685" locator="305:21-305:41" xsi:type="Start">
                        <operand localId="684" locator="305:30-305:41" name="boundsPeriod" xsi:type="QueryLetRef"/>
                     </operand>
                  </operand>
                  <operand localId="689" locator="306:11-306:32" xsi:type="DateFrom">
                     <operand localId="688" locator="306:21-306:32" path="value" xsi:type="Property">
                        <source path="authoredOn" scope="R" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand localId="694" locator="307:11-307:61" xsi:type="DateFrom">
                     <operand localId="693" locator="307:21-307:61" xsi:type="Start">
                        <operand localId="692" locator="307:30-307:61" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand path="validityPeriod" xsi:type="Property">
                              <source localId="691" locator="307:30-307:46" path="dispenseRequest" scope="R" xsi:type="Property"/>
                           </operand>
                        </operand>
                     </operand>
                  </operand>
               </expression>
            </let>
            <let localId="710" locator="309:7-309:106" identifier="totalDaysSupplied">
               <expression localId="709" locator="309:26-309:106" xsi:type="Multiply">
                  <operand localId="705" locator="309:26-309:90" xsi:type="Coalesce">
                     <operand localId="697" locator="309:35-309:44" name="daysSupply" xsi:type="QueryLetRef"/>
                     <operand localId="704" locator="309:47-309:89" xsi:type="Divide">
                        <operand localId="699" locator="309:47-309:60" path="value" xsi:type="Property">
                           <source localId="698" locator="309:47-309:54" name="quantity" xsi:type="QueryLetRef"/>
                        </operand>
                        <operand localId="703" locator="309:64-309:89" xsi:type="Multiply">
                           <operand localId="701" locator="309:65-309:74" path="value" xsi:type="Property">
                              <source localId="700" locator="309:65-309:68" name="dose" xsi:type="QueryLetRef"/>
                           </operand>
                           <operand localId="702" locator="309:78-309:88" name="dosesPerDay" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="708" locator="309:94-309:106" xsi:type="Add">
                        <operand localId="706" locator="309:95" valueType="t:Integer" value="1" xsi:type="Literal"/>
                        <operand localId="707" locator="309:99-309:105" name="refills" xsi:type="QueryLetRef"/>
                     </operand>
                  </operand>
               </expression>
            </let>
            <return localId="756" locator="310:5-318:13">
               <expression localId="755" locator="310:12-318:13" xsi:type="Tuple">
                  <element name="dosage">
                     <value localId="711" locator="310:22-310:27" name="dosage" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="doseAndRate">
                     <value localId="712" locator="310:43-310:53" name="doseAndRate" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="timing">
                     <value localId="713" locator="310:64-310:69" name="timing" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="frequency">
                     <value localId="714" locator="310:83-310:91" name="frequency" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="period">
                     <value localId="715" locator="310:102-310:107" name="period" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="doseRange">
                     <value localId="716" locator="311:18-311:26" name="doseRange" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="doseQuantity">
                     <value localId="717" locator="311:43-311:54" name="doseQuantity" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="dose">
                     <value localId="718" locator="311:63-311:66" name="dose" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="dosesPerDay">
                     <value localId="719" locator="311:82-311:92" name="dosesPerDay" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="boundsPeriod">
                     <value localId="720" locator="311:109-311:120" name="boundsPeriod" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="expectedDaysSupply">
                     <value localId="721" locator="312:27-312:44" name="expectedDaysSupply" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="daysSupply">
                     <value localId="722" locator="312:59-312:68" name="daysSupply" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="quantity">
                     <value localId="723" locator="312:81-312:88" name="quantity" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="refills">
                     <value localId="724" locator="312:100-312:106" name="refills" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="startDate">
                     <value localId="725" locator="312:120-312:128" name="startDate" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="totalDaysSupplied">
                     <value localId="726" locator="312:150-312:166" name="totalDaysSupplied" xsi:type="QueryLetRef"/>
                  </element>
                  <element name="requestPeriod">
                     <value localId="754" locator="313:22-318:12" xsi:type="If">
                        <condition localId="731" locator="313:25-313:79" xsi:type="And">
                           <operand localId="728" locator="313:25-313:45" xsi:type="Not">
                              <operand locator="313:25-313:45" xsi:type="IsNull">
                                 <operand localId="727" locator="313:25-313:33" name="startDate" xsi:type="QueryLetRef"/>
                              </operand>
                           </operand>
                           <operand localId="730" locator="313:51-313:79" xsi:type="Not">
                              <operand locator="313:51-313:79" xsi:type="IsNull">
                                 <operand localId="729" locator="313:51-313:67" name="totalDaysSupplied" xsi:type="QueryLetRef"/>
                              </operand>
                           </operand>
                        </condition>
                        <then localId="740" locator="314:9-314:80" lowClosed="true" highClosed="true" xsi:type="Interval">
                           <low localId="732" locator="314:18-314:26" name="startDate" xsi:type="QueryLetRef"/>
                           <high localId="739" locator="314:29-314:78" xsi:type="Add">
                              <operand localId="733" locator="314:29-314:37" name="startDate" xsi:type="QueryLetRef"/>
                              <operand localId="738" locator="314:41-314:78" name="Quantity" xsi:type="FunctionRef">
                                 <operand localId="736" locator="314:50-314:70" xsi:type="Subtract">
                                    <operand localId="734" locator="314:50-314:66" name="totalDaysSupplied" xsi:type="QueryLetRef"/>
                                    <operand xsi:type="ToDecimal">
                                       <operand localId="735" locator="314:70" valueType="t:Integer" value="1" xsi:type="Literal"/>
                                    </operand>
                                 </operand>
                                 <operand localId="737" locator="314:73-314:77" valueType="t:String" value="day" xsi:type="Literal"/>
                              </operand>
                           </high>
                        </then>
                        <else localId="753" locator="315:12-318:12" xsi:type="If">
                           <condition localId="746" locator="315:15-315:71" xsi:type="And">
                              <operand localId="742" locator="315:15-315:35" xsi:type="Not">
                                 <operand locator="315:15-315:35" xsi:type="IsNull">
                                    <operand localId="741" locator="315:15-315:23" name="startDate" xsi:type="QueryLetRef"/>
                                 </operand>
                              </operand>
                              <operand localId="745" locator="315:41-315:71" xsi:type="Not">
                                 <operand locator="315:41-315:71" xsi:type="IsNull">
                                    <operand localId="744" locator="315:41-315:59" path="high" xsi:type="Property">
                                       <source localId="743" locator="315:41-315:52" name="boundsPeriod" xsi:type="QueryLetRef"/>
                                    </operand>
                                 </operand>
                              </operand>
                           </condition>
                           <then localId="751" locator="316:9-316:58" lowClosed="true" highClosed="true" xsi:type="Interval">
                              <low localId="747" locator="316:18-316:26" name="startDate" xsi:type="QueryLetRef"/>
                              <high localId="750" locator="316:29-316:57" xsi:type="DateFrom">
                                 <operand localId="749" locator="316:39-316:57" xsi:type="End">
                                    <operand localId="748" locator="316:46-316:57" name="boundsPeriod" xsi:type="QueryLetRef"/>
                                 </operand>
                              </high>
                           </then>
                           <else xsi:type="As">
                              <operand localId="752" locator="318:9-318:12" xsi:type="Null"/>
                              <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                                 <pointType name="t:Date" xsi:type="NamedTypeSpecifier"/>
                              </asTypeSpecifier>
                           </else>
                        </else>
                     </value>
                  </element>
               </expression>
            </return>
         </expression>
         <operand name="Request">
            <operandTypeSpecifier localId="596" locator="284:53-284:85" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="889" locator="320:1-351:12" name="MedicationRequestPeriod" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="889">
               <a:s>define function MedicationRequestPeriod(Request </a:s>
               <a:s r="759">
                  <a:s>USCore.&quot;MedicationRequestProfile&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="888">
                  <a:s r="888">
                     <a:s>
                        <a:s r="761">
                           <a:s r="760">
                              <a:s>
                                 <a:s>Request</a:s>
                              </a:s>
                           </a:s>
                           <a:s> R</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s>
                        <a:s>let
      </a:s>
                        <a:s r="765">
                           <a:s>dosage: </a:s>
                           <a:s r="764">
                              <a:s>singleton from </a:s>
                              <a:s r="763">
                                 <a:s r="762">
                                    <a:s>R</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="763">
                                    <a:s>dosageInstruction</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="769">
                           <a:s>doseAndRate: </a:s>
                           <a:s r="768">
                              <a:s>singleton from </a:s>
                              <a:s r="767">
                                 <a:s r="766">
                                    <a:s>dosage</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="767">
                                    <a:s>doseAndRate</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="772">
                           <a:s>timing: </a:s>
                           <a:s r="771">
                              <a:s r="770">
                                 <a:s>dosage</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="771">
                                 <a:s>timing</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="780">
                           <a:s>frequency: </a:s>
                           <a:s r="779">
                              <a:s>Coalesce(</a:s>
                              <a:s r="775">
                                 <a:s r="774">
                                    <a:s r="773">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="774">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="775">
                                    <a:s>frequencyMax</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="778">
                                 <a:s r="777">
                                    <a:s r="776">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="777">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="778">
                                    <a:s>frequency</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="788">
                           <a:s>period: </a:s>
                           <a:s r="787">
                              <a:s>Quantity(</a:s>
                              <a:s r="783">
                                 <a:s r="782">
                                    <a:s r="781">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="782">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="783">
                                    <a:s>period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="786">
                                 <a:s r="785">
                                    <a:s r="784">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="785">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="786">
                                    <a:s>periodUnit</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="791">
                           <a:s>doseRange: </a:s>
                           <a:s r="790">
                              <a:s r="789">
                                 <a:s>doseAndRate</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="790">
                                 <a:s>dose</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="794">
                           <a:s>doseQuantity: </a:s>
                           <a:s r="793">
                              <a:s r="792">
                                 <a:s>doseAndRate</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="793">
                                 <a:s>dose</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="799">
                           <a:s>dose: </a:s>
                           <a:s r="798">
                              <a:s>Coalesce(</a:s>
                              <a:s r="796">
                                 <a:s>end of </a:s>
                                 <a:s r="795">
                                    <a:s>doseRange</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="797">
                                 <a:s>doseQuantity</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="809">
                           <a:s>dosesPerDay: </a:s>
                           <a:s r="808">
                              <a:s>Coalesce(</a:s>
                              <a:s r="802">
                                 <a:s>ToDaily(</a:s>
                                 <a:s r="800">
                                    <a:s>frequency</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="801">
                                    <a:s>period</a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="806">
                                 <a:s>Count(</a:s>
                                 <a:s r="805">
                                    <a:s r="804">
                                       <a:s r="803">
                                          <a:s>timing</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="804">
                                          <a:s>repeat</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="805">
                                       <a:s>timeOfDay</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="807">, 1.0)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="816">
                           <a:s>boundsPeriod: </a:s>
                           <a:s r="815">
                              <a:s r="812">
                                 <a:s r="811">
                                    <a:s r="810">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="811">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="812">
                                    <a:s>bounds</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> as </a:s>
                              <a:s r="814">
                                 <a:s>Interval&lt;</a:s>
                                 <a:s r="813">
                                    <a:s>DateTime</a:s>
                                 </a:s>
                                 <a:s>></a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      // TODO: this isn't working as expected, convert results in null
      //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value,
      </a:s>
                        <a:s r="821">
                           <a:s>daysSupply: </a:s>
                           <a:s r="820">
                              <a:s r="819">
                                 <a:s>(</a:s>
                                 <a:s r="819">
                                    <a:s r="818">
                                       <a:s r="817">
                                          <a:s>R</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="818">
                                          <a:s>dispenseRequest</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="819">
                                       <a:s>expectedSupplyDuration</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="820">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="825">
                           <a:s>quantity: </a:s>
                           <a:s r="824">
                              <a:s r="823">
                                 <a:s r="822">
                                    <a:s>R</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="823">
                                    <a:s>dispenseRequest</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="824">
                                 <a:s>quantity</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="831">
                           <a:s>refills: </a:s>
                           <a:s r="830">
                              <a:s>Coalesce(</a:s>
                              <a:s r="828">
                                 <a:s r="827">
                                    <a:s r="826">
                                       <a:s>R</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="827">
                                       <a:s>dispenseRequest</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="828">
                                    <a:s>numberOfRepeatsAllowed</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="829">, 0)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="844">
                           <a:s>startDate:
        </a:s>
                           <a:s r="843">
                              <a:s>Coalesce(
          </a:s>
                              <a:s r="834">
                                 <a:s>date from </a:s>
                                 <a:s r="833">
                                    <a:s>start of </a:s>
                                    <a:s r="832">
                                       <a:s>boundsPeriod</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>,
          </a:s>
                              <a:s r="837">
                                 <a:s>date from </a:s>
                                 <a:s r="836">
                                    <a:s r="835">
                                       <a:s>R</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="836">
                                       <a:s>authoredOn</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>,
          </a:s>
                              <a:s r="842">
                                 <a:s>date from </a:s>
                                 <a:s r="841">
                                    <a:s>start of </a:s>
                                    <a:s r="840">
                                       <a:s r="839">
                                          <a:s r="838">
                                             <a:s>R</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="839">
                                             <a:s>dispenseRequest</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="840">
                                          <a:s>validityPeriod</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
        )</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="858">
                           <a:s>totalDaysSupplied: </a:s>
                           <a:s r="857">
                              <a:s r="853">
                                 <a:s>Coalesce(</a:s>
                                 <a:s r="845">
                                    <a:s>daysSupply</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="852">
                                    <a:s r="847">
                                       <a:s r="846">
                                          <a:s>quantity</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="847">
                                          <a:s>value</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> / </a:s>
                                    <a:s r="851">
                                       <a:s>(</a:s>
                                       <a:s r="851">
                                          <a:s r="849">
                                             <a:s r="848">
                                                <a:s>dose</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="849">
                                                <a:s>value</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> * </a:s>
                                          <a:s r="850">
                                             <a:s>dosesPerDay</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s> * </a:s>
                              <a:s r="856">
                                 <a:s>(</a:s>
                                 <a:s r="856">
                                    <a:s r="854">1 + </a:s>
                                    <a:s r="855">
                                       <a:s>refills</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="887">
                        <a:s>return
      </a:s>
                        <a:s r="886">
                           <a:s>if </a:s>
                           <a:s r="863">
                              <a:s r="860">
                                 <a:s r="859">
                                    <a:s>startDate</a:s>
                                 </a:s>
                                 <a:s> is not null</a:s>
                              </a:s>
                              <a:s> and </a:s>
                              <a:s r="862">
                                 <a:s r="861">
                                    <a:s>totalDaysSupplied</a:s>
                                 </a:s>
                                 <a:s> is not null</a:s>
                              </a:s>
                           </a:s>
                           <a:s> then
        </a:s>
                           <a:s r="872">
                              <a:s>Interval[</a:s>
                              <a:s r="864">
                                 <a:s>startDate</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="871">
                                 <a:s r="865">
                                    <a:s>startDate</a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="870">
                                    <a:s>Quantity(</a:s>
                                    <a:s r="868">
                                       <a:s r="866">
                                          <a:s>totalDaysSupplied</a:s>
                                       </a:s>
                                       <a:s r="867"> - 1</a:s>
                                    </a:s>
                                    <a:s>, </a:s>
                                    <a:s r="869">
                                       <a:s>'day'</a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ]</a:s>
                           </a:s>
                           <a:s>
      else </a:s>
                           <a:s r="885">
                              <a:s>if </a:s>
                              <a:s r="878">
                                 <a:s r="874">
                                    <a:s r="873">
                                       <a:s>startDate</a:s>
                                    </a:s>
                                    <a:s> is not null</a:s>
                                 </a:s>
                                 <a:s> and </a:s>
                                 <a:s r="877">
                                    <a:s r="876">
                                       <a:s r="875">
                                          <a:s>boundsPeriod</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="876">
                                          <a:s>&quot;high&quot;</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> is not null</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> then
        </a:s>
                              <a:s r="883">
                                 <a:s>Interval[</a:s>
                                 <a:s r="879">
                                    <a:s>startDate</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="882">
                                    <a:s>date from </a:s>
                                    <a:s r="881">
                                       <a:s>end of </a:s>
                                       <a:s r="880">
                                          <a:s>boundsPeriod</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>]</a:s>
                              </a:s>
                              <a:s r="884">
      else
        null</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="888" locator="321:3-351:12" xsi:type="Query">
            <source localId="761" locator="321:3-321:11" alias="R">
               <expression localId="760" locator="321:3-321:9" name="Request" xsi:type="OperandRef"/>
            </source>
            <let localId="765" locator="323:7-323:48" identifier="dosage">
               <expression localId="764" locator="323:15-323:48" xsi:type="SingletonFrom">
                  <operand localId="763" locator="323:30-323:48" path="dosageInstruction" scope="R" xsi:type="Property"/>
               </expression>
            </let>
            <let localId="769" locator="324:7-324:52" identifier="doseAndRate">
               <expression localId="768" locator="324:20-324:52" xsi:type="SingletonFrom">
                  <operand localId="767" locator="324:35-324:52" path="doseAndRate" xsi:type="Property">
                     <source localId="766" locator="324:35-324:40" name="dosage" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="772" locator="325:7-325:27" identifier="timing">
               <expression localId="771" locator="325:15-325:27" path="timing" xsi:type="Property">
                  <source localId="770" locator="325:15-325:20" name="dosage" xsi:type="QueryLetRef"/>
               </expression>
            </let>
            <let localId="780" locator="326:7-326:78" identifier="frequency">
               <expression localId="779" locator="326:18-326:78" xsi:type="Coalesce">
                  <operand localId="775" locator="326:27-326:52" path="value" xsi:type="Property">
                     <source path="frequencyMax" xsi:type="Property">
                        <source localId="774" locator="326:27-326:39" path="repeat" xsi:type="Property">
                           <source localId="773" locator="326:27-326:32" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
                  <operand localId="778" locator="326:55-326:77" path="value" xsi:type="Property">
                     <source path="frequency" xsi:type="Property">
                        <source localId="777" locator="326:55-326:67" path="repeat" xsi:type="Property">
                           <source localId="776" locator="326:55-326:60" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
               </expression>
            </let>
            <let localId="788" locator="327:7-327:70" identifier="period">
               <expression localId="787" locator="327:15-327:70" name="Quantity" xsi:type="FunctionRef">
                  <operand localId="783" locator="327:24-327:43" path="value" xsi:type="Property">
                     <source path="period" xsi:type="Property">
                        <source localId="782" locator="327:24-327:36" path="repeat" xsi:type="Property">
                           <source localId="781" locator="327:24-327:29" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
                  <operand localId="786" locator="327:46-327:69" path="value" xsi:type="Property">
                     <source path="periodUnit" xsi:type="Property">
                        <source localId="785" locator="327:46-327:58" path="repeat" xsi:type="Property">
                           <source localId="784" locator="327:46-327:51" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </source>
                  </operand>
               </expression>
            </let>
            <let localId="791" locator="328:7-328:33" identifier="doseRange">
               <expression localId="790" locator="328:18-328:33" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="dose" xsi:type="Property">
                     <source localId="789" locator="328:18-328:28" name="doseAndRate" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="794" locator="329:7-329:36" identifier="doseQuantity">
               <expression localId="793" locator="329:21-329:36" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="dose" xsi:type="Property">
                     <source localId="792" locator="329:21-329:31" name="doseAndRate" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="799" locator="330:7-330:52" identifier="dose">
               <expression localId="798" locator="330:13-330:52" xsi:type="Coalesce">
                  <operand localId="796" locator="330:22-330:37" xsi:type="End">
                     <operand xsi:type="As">
                        <operand localId="795" locator="330:29-330:37" name="doseRange" xsi:type="QueryLetRef"/>
                        <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                           <pointType name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        </asTypeSpecifier>
                     </operand>
                  </operand>
                  <operand asType="t:Quantity" xsi:type="As">
                     <operand localId="797" locator="330:40-330:51" name="doseQuantity" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="809" locator="331:7-331:92" identifier="dosesPerDay">
               <expression localId="808" locator="331:20-331:92" xsi:type="Coalesce">
                  <operand localId="802" locator="331:29-331:54" name="ToDaily" xsi:type="FunctionRef">
                     <operand localId="800" locator="331:37-331:45" name="frequency" xsi:type="QueryLetRef"/>
                     <operand localId="801" locator="331:48-331:53" name="period" xsi:type="QueryLetRef"/>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="806" locator="331:57-331:86" xsi:type="Count">
                        <source localId="805" locator="331:63-331:85" path="value" xsi:type="Property">
                           <source path="timeOfDay" xsi:type="Property">
                              <source localId="804" locator="331:63-331:75" path="repeat" xsi:type="Property">
                                 <source localId="803" locator="331:63-331:68" name="timing" xsi:type="QueryLetRef"/>
                              </source>
                           </source>
                        </source>
                     </operand>
                  </operand>
                  <operand localId="807" locator="331:89-331:91" valueType="t:Decimal" value="1.0" xsi:type="Literal"/>
               </expression>
            </let>
            <let localId="816" locator="332:7-332:62" identifier="boundsPeriod">
               <expression localId="815" locator="332:21-332:62" strict="false" xsi:type="As">
                  <operand localId="812" locator="332:21-332:40" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="bounds" xsi:type="Property">
                        <source localId="811" locator="332:21-332:33" path="repeat" xsi:type="Property">
                           <source localId="810" locator="332:21-332:26" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </operand>
                  </operand>
                  <asTypeSpecifier localId="814" locator="332:45-332:62" xsi:type="IntervalTypeSpecifier">
                     <pointType localId="813" locator="332:54-332:61" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                  </asTypeSpecifier>
               </expression>
            </let>
            <let localId="821" locator="335:7-335:66" identifier="daysSupply">
               <expression localId="820" locator="335:19-335:66" path="value" xsi:type="Property">
                  <source localId="819" locator="335:19-335:60" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="expectedSupplyDuration" xsi:type="Property">
                        <source localId="818" locator="335:20-335:36" path="dispenseRequest" scope="R" xsi:type="Property"/>
                     </operand>
                  </source>
               </expression>
            </let>
            <let localId="825" locator="336:7-336:42" identifier="quantity">
               <expression localId="824" locator="336:17-336:42" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="quantity" xsi:type="Property">
                     <source localId="823" locator="336:17-336:33" path="dispenseRequest" scope="R" xsi:type="Property"/>
                  </operand>
               </expression>
            </let>
            <let localId="831" locator="337:7-337:68" identifier="refills">
               <expression localId="830" locator="337:16-337:68" xsi:type="Coalesce">
                  <operand localId="828" locator="337:25-337:64" path="value" xsi:type="Property">
                     <source path="numberOfRepeatsAllowed" xsi:type="Property">
                        <source localId="827" locator="337:25-337:41" path="dispenseRequest" scope="R" xsi:type="Property"/>
                     </source>
                  </operand>
                  <operand localId="829" locator="337:67" valueType="t:Integer" value="0" xsi:type="Literal"/>
               </expression>
            </let>
            <let localId="844" locator="338:7-343:9" identifier="startDate">
               <expression localId="843" locator="339:9-343:9" xsi:type="Coalesce">
                  <operand localId="834" locator="340:11-340:41" xsi:type="DateFrom">
                     <operand localId="833" locator="340:21-340:41" xsi:type="Start">
                        <operand localId="832" locator="340:30-340:41" name="boundsPeriod" xsi:type="QueryLetRef"/>
                     </operand>
                  </operand>
                  <operand localId="837" locator="341:11-341:32" xsi:type="DateFrom">
                     <operand localId="836" locator="341:21-341:32" path="value" xsi:type="Property">
                        <source path="authoredOn" scope="R" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand localId="842" locator="342:11-342:61" xsi:type="DateFrom">
                     <operand localId="841" locator="342:21-342:61" xsi:type="Start">
                        <operand localId="840" locator="342:30-342:61" name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand path="validityPeriod" xsi:type="Property">
                              <source localId="839" locator="342:30-342:46" path="dispenseRequest" scope="R" xsi:type="Property"/>
                           </operand>
                        </operand>
                     </operand>
                  </operand>
               </expression>
            </let>
            <let localId="858" locator="344:7-344:106" identifier="totalDaysSupplied">
               <expression localId="857" locator="344:26-344:106" xsi:type="Multiply">
                  <operand localId="853" locator="344:26-344:90" xsi:type="Coalesce">
                     <operand localId="845" locator="344:35-344:44" name="daysSupply" xsi:type="QueryLetRef"/>
                     <operand localId="852" locator="344:47-344:89" xsi:type="Divide">
                        <operand localId="847" locator="344:47-344:60" path="value" xsi:type="Property">
                           <source localId="846" locator="344:47-344:54" name="quantity" xsi:type="QueryLetRef"/>
                        </operand>
                        <operand localId="851" locator="344:64-344:89" xsi:type="Multiply">
                           <operand localId="849" locator="344:65-344:74" path="value" xsi:type="Property">
                              <source localId="848" locator="344:65-344:68" name="dose" xsi:type="QueryLetRef"/>
                           </operand>
                           <operand localId="850" locator="344:78-344:88" name="dosesPerDay" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="856" locator="344:94-344:106" xsi:type="Add">
                        <operand localId="854" locator="344:95" valueType="t:Integer" value="1" xsi:type="Literal"/>
                        <operand localId="855" locator="344:99-344:105" name="refills" xsi:type="QueryLetRef"/>
                     </operand>
                  </operand>
               </expression>
            </let>
            <return localId="887" locator="345:5-351:12">
               <expression localId="886" locator="346:7-351:12" xsi:type="If">
                  <condition localId="863" locator="346:10-346:64" xsi:type="And">
                     <operand localId="860" locator="346:10-346:30" xsi:type="Not">
                        <operand locator="346:10-346:30" xsi:type="IsNull">
                           <operand localId="859" locator="346:10-346:18" name="startDate" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                     <operand localId="862" locator="346:36-346:64" xsi:type="Not">
                        <operand locator="346:36-346:64" xsi:type="IsNull">
                           <operand localId="861" locator="346:36-346:52" name="totalDaysSupplied" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                  </condition>
                  <then localId="872" locator="347:9-347:80" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="864" locator="347:18-347:26" name="startDate" xsi:type="QueryLetRef"/>
                     <high localId="871" locator="347:29-347:78" xsi:type="Add">
                        <operand localId="865" locator="347:29-347:37" name="startDate" xsi:type="QueryLetRef"/>
                        <operand localId="870" locator="347:41-347:78" name="Quantity" xsi:type="FunctionRef">
                           <operand localId="868" locator="347:50-347:70" xsi:type="Subtract">
                              <operand localId="866" locator="347:50-347:66" name="totalDaysSupplied" xsi:type="QueryLetRef"/>
                              <operand xsi:type="ToDecimal">
                                 <operand localId="867" locator="347:70" valueType="t:Integer" value="1" xsi:type="Literal"/>
                              </operand>
                           </operand>
                           <operand localId="869" locator="347:73-347:77" valueType="t:String" value="day" xsi:type="Literal"/>
                        </operand>
                     </high>
                  </then>
                  <else localId="885" locator="348:12-351:12" xsi:type="If">
                     <condition localId="878" locator="348:15-348:71" xsi:type="And">
                        <operand localId="874" locator="348:15-348:35" xsi:type="Not">
                           <operand locator="348:15-348:35" xsi:type="IsNull">
                              <operand localId="873" locator="348:15-348:23" name="startDate" xsi:type="QueryLetRef"/>
                           </operand>
                        </operand>
                        <operand localId="877" locator="348:41-348:71" xsi:type="Not">
                           <operand locator="348:41-348:71" xsi:type="IsNull">
                              <operand localId="876" locator="348:41-348:59" path="high" xsi:type="Property">
                                 <source localId="875" locator="348:41-348:52" name="boundsPeriod" xsi:type="QueryLetRef"/>
                              </operand>
                           </operand>
                        </operand>
                     </condition>
                     <then localId="883" locator="349:9-349:58" lowClosed="true" highClosed="true" xsi:type="Interval">
                        <low localId="879" locator="349:18-349:26" name="startDate" xsi:type="QueryLetRef"/>
                        <high localId="882" locator="349:29-349:57" xsi:type="DateFrom">
                           <operand localId="881" locator="349:39-349:57" xsi:type="End">
                              <operand localId="880" locator="349:46-349:57" name="boundsPeriod" xsi:type="QueryLetRef"/>
                           </operand>
                        </high>
                     </then>
                     <else xsi:type="As">
                        <operand localId="884" locator="351:9-351:12" xsi:type="Null"/>
                        <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                           <pointType name="t:Date" xsi:type="NamedTypeSpecifier"/>
                        </asTypeSpecifier>
                     </else>
                  </else>
               </expression>
            </return>
         </expression>
         <operand name="Request">
            <operandTypeSpecifier localId="759" locator="320:49-320:81" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="983" locator="435:1-458:12" name="MedicationDispensePeriod" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="983">
               <a:s>/*
Next, consider the MedicationDispense case:

* whenPrepared: When product was prepared
* whenHandedOver: When product was given out
* quantity: Amount dispensed
* daysSupply: Amount of medication expressed as a timing amount
* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat
* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat
* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat
* dosageInstruction.timing.repeat.count: number of times to repeat
* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat
* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period
* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period
* dosageInstruction.timing.repeat.period: event occurs frequency times per period
* dosageInstruction.timing.repeat.periodMax: upper limit of period
* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a)
* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*)
* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...)
* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD...
* dosageInstruction.asNeeded
* dosageInstruction.doseAndRate.doseQuantity
* dosageInstruction.doseAndRate.doseRange

We have effectively the same elements, with the same meanings, with the exception that the
event is documenting a single dispense, and does not contain refill information. In addition,
multiple dispense events would typically be present, and those would all have to be considered
as part of an overall calculation. That will be considered when we combine results, but for
this function, we'll focus on calculating the duration of a single dispense.

With a MedicationDispense, dosage information is expected to be the same as the related
MedicationRequest, so boundsPeriod would still cover the entire prescription (including refills)
and so cannot be used to calculate the interval covered by the dispense.

If the daysSupply element is present, then the duration in days is simply

    daysSupply

Note specifically that we are not considering refills, as those would be covered
by subsequent dispense records.

If daysSupplied is not present, then daysSupplied must be calculated based on
the quantity, dosage, and frequency:

    (quantity / (dosage * frequency))

This calculation results in a number of days, which can then be turned into a
period by anchoring that to the startDate, as determined by the first available
value of the start of the boundsPeriod, whenHandedOver, and whenPrepared.

   Interval[startDate, startDate + totalDaysSupplied - 1 day]
*/

/*
Calculates Medication Period for a given MedicationDispense
MedicationDispense instances provided to this function are expected
to conform to the [TODO: MMEMedicationDispense](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationdispense.html)
profile, which expects:
* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error
* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error
* 1 timing with 1 repeat, missing timing or repeat elements will result in a null
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* timeOfDay
* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null
* whenHandedOver or whenPrepared, if missing both whenHandedOver and whenPrepared will result in a null

Note that MedicationDispense status is not considered by this calculation, as the
list of MedicationDispense instances provided to this function should already have
considered appropriate statuses, depending on the use case, typically `completed`,
especially since whenHandedOver would be expected to be present for a completed
MedicationDispense.

Note also that the dosage information recorded in a dispense is expected to be a copy of the
dispense information from the related medication request. As such, the boundsPeriod would be expected
to cover the entire range, and should _not_ be used for timing of the event.

There is also active discussion in the Pharmacy WG about what date should be used if whenPrepared/whenHandedOver is not present.
This may take the form of an &quot;original creation date&quot;, but may also be a &quot;status change date&quot; for dispense events that are updating
status of an existing dispense. That discussion is ongoing, so until that is resolved, this logic will return
null if whenPrepared/whenHandedOver are not available.
*/
define function MedicationDispensePeriod(Dispense </a:s>
               <a:s r="890">
                  <a:s>&quot;MedicationDispense&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="982">
                  <a:s r="982">
                     <a:s>
                        <a:s r="892">
                           <a:s r="891">
                              <a:s>
                                 <a:s>Dispense</a:s>
                              </a:s>
                           </a:s>
                           <a:s> D</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s>
                        <a:s>let
      </a:s>
                        <a:s r="896">
                           <a:s>dosage: </a:s>
                           <a:s r="895">
                              <a:s>singleton from </a:s>
                              <a:s r="894">
                                 <a:s r="893">
                                    <a:s>D</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="894">
                                    <a:s>dosageInstruction</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="900">
                           <a:s>doseAndRate: </a:s>
                           <a:s r="899">
                              <a:s>singleton from </a:s>
                              <a:s r="898">
                                 <a:s r="897">
                                    <a:s>dosage</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="898">
                                    <a:s>doseAndRate</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="903">
                           <a:s>timing: </a:s>
                           <a:s r="902">
                              <a:s r="901">
                                 <a:s>dosage</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="902">
                                 <a:s>timing</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="911">
                           <a:s>frequency: </a:s>
                           <a:s r="910">
                              <a:s>Coalesce(</a:s>
                              <a:s r="906">
                                 <a:s r="905">
                                    <a:s r="904">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="905">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="906">
                                    <a:s>frequencyMax</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="909">
                                 <a:s r="908">
                                    <a:s r="907">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="908">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="909">
                                    <a:s>frequency</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="919">
                           <a:s>period: </a:s>
                           <a:s r="918">
                              <a:s>Quantity(</a:s>
                              <a:s r="914">
                                 <a:s r="913">
                                    <a:s r="912">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="913">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="914">
                                    <a:s>period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="917">
                                 <a:s r="916">
                                    <a:s r="915">
                                       <a:s>timing</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="916">
                                       <a:s>repeat</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="917">
                                    <a:s>periodUnit</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="922">
                           <a:s>doseRange: </a:s>
                           <a:s r="921">
                              <a:s r="920">
                                 <a:s>doseAndRate</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="921">
                                 <a:s>dose</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="925">
                           <a:s>doseQuantity: </a:s>
                           <a:s r="924">
                              <a:s r="923">
                                 <a:s>doseAndRate</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="924">
                                 <a:s>dose</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="930">
                           <a:s>dose: </a:s>
                           <a:s r="929">
                              <a:s>Coalesce(</a:s>
                              <a:s r="927">
                                 <a:s>end of </a:s>
                                 <a:s r="926">
                                    <a:s>doseRange</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="928">
                                 <a:s>doseQuantity</a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="935">
                           <a:s>daysSupply: </a:s>
                           <a:s r="934">
                              <a:s r="933">
                                 <a:s>(</a:s>
                                 <a:s r="933">
                                    <a:s>convert </a:s>
                                    <a:s r="932">
                                       <a:s r="931">
                                          <a:s>D</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="932">
                                          <a:s>daysSupply</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> to days</a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="934">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="945">
                           <a:s>dosesPerDay: </a:s>
                           <a:s r="944">
                              <a:s>Coalesce(</a:s>
                              <a:s r="938">
                                 <a:s>ToDaily(</a:s>
                                 <a:s r="936">
                                    <a:s>frequency</a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="937">
                                    <a:s>period</a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="942">
                                 <a:s>Count(</a:s>
                                 <a:s r="941">
                                    <a:s r="940">
                                       <a:s r="939">
                                          <a:s>timing</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="940">
                                          <a:s>repeat</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="941">
                                       <a:s>timeOfDay</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="943">, 1.0)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="953">
                           <a:s>startDate:
        </a:s>
                           <a:s r="952">
                              <a:s>Coalesce(
          </a:s>
                              <a:s r="948">
                                 <a:s>date from </a:s>
                                 <a:s r="947">
                                    <a:s r="946">
                                       <a:s>D</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="947">
                                       <a:s>whenHandedOver</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>,
          </a:s>
                              <a:s r="951">
                                 <a:s>date from </a:s>
                                 <a:s r="950">
                                    <a:s r="949">
                                       <a:s>D</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="950">
                                       <a:s>whenPrepared</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
        )</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="964">
                           <a:s>totalDaysSupplied: </a:s>
                           <a:s r="963">
                              <a:s>Coalesce(</a:s>
                              <a:s r="954">
                                 <a:s>daysSupply</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="962">
                                 <a:s r="957">
                                    <a:s r="956">
                                       <a:s r="955">
                                          <a:s>D</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="956">
                                          <a:s>quantity</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="957">
                                       <a:s>value</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> / </a:s>
                                 <a:s r="961">
                                    <a:s>(</a:s>
                                    <a:s r="961">
                                       <a:s r="959">
                                          <a:s r="958">
                                             <a:s>dose</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="959">
                                             <a:s>value</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> * </a:s>
                                       <a:s r="960">
                                          <a:s>dosesPerDay</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="981">
                        <a:s>return
      </a:s>
                        <a:s r="980">
                           <a:s>if </a:s>
                           <a:s r="969">
                              <a:s r="966">
                                 <a:s r="965">
                                    <a:s>startDate</a:s>
                                 </a:s>
                                 <a:s> is not null</a:s>
                              </a:s>
                              <a:s> and </a:s>
                              <a:s r="968">
                                 <a:s r="967">
                                    <a:s>totalDaysSupplied</a:s>
                                 </a:s>
                                 <a:s> is not null</a:s>
                              </a:s>
                           </a:s>
                           <a:s> then
        </a:s>
                           <a:s r="978">
                              <a:s>Interval[</a:s>
                              <a:s r="970">
                                 <a:s>startDate</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="977">
                                 <a:s r="971">
                                    <a:s>startDate</a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="976">
                                    <a:s>Quantity(</a:s>
                                    <a:s r="974">
                                       <a:s r="972">
                                          <a:s>totalDaysSupplied</a:s>
                                       </a:s>
                                       <a:s r="973"> - 1</a:s>
                                    </a:s>
                                    <a:s>, </a:s>
                                    <a:s r="975">
                                       <a:s>'day'</a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                           <a:s r="979">
      else
        null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="982" locator="436:3-458:12" xsi:type="Query">
            <source localId="892" locator="436:3-436:12" alias="D">
               <expression localId="891" locator="436:3-436:10" name="Dispense" xsi:type="OperandRef"/>
            </source>
            <let localId="896" locator="438:7-438:48" identifier="dosage">
               <expression localId="895" locator="438:15-438:48" xsi:type="SingletonFrom">
                  <operand localId="894" locator="438:30-438:48" path="dosageInstruction" scope="D" xsi:type="Property"/>
               </expression>
            </let>
            <let localId="900" locator="439:7-439:52" identifier="doseAndRate">
               <expression localId="899" locator="439:20-439:52" xsi:type="SingletonFrom">
                  <operand localId="898" locator="439:35-439:52" path="doseAndRate" xsi:type="Property">
                     <source localId="897" locator="439:35-439:40" name="dosage" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="903" locator="440:7-440:27" identifier="timing">
               <expression localId="902" locator="440:15-440:27" path="timing" xsi:type="Property">
                  <source localId="901" locator="440:15-440:20" name="dosage" xsi:type="QueryLetRef"/>
               </expression>
            </let>
            <let localId="911" locator="441:7-441:78" identifier="frequency">
               <expression localId="910" locator="441:18-441:78" xsi:type="Coalesce">
                  <operand localId="906" locator="441:27-441:52" path="frequencyMax" xsi:type="Property">
                     <source localId="905" locator="441:27-441:39" path="repeat" xsi:type="Property">
                        <source localId="904" locator="441:27-441:32" name="timing" xsi:type="QueryLetRef"/>
                     </source>
                  </operand>
                  <operand localId="909" locator="441:55-441:77" path="frequency" xsi:type="Property">
                     <source localId="908" locator="441:55-441:67" path="repeat" xsi:type="Property">
                        <source localId="907" locator="441:55-441:60" name="timing" xsi:type="QueryLetRef"/>
                     </source>
                  </operand>
               </expression>
            </let>
            <let localId="919" locator="442:7-442:70" identifier="period">
               <expression localId="918" locator="442:15-442:70" name="Quantity" xsi:type="FunctionRef">
                  <operand name="ToDecimal" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="914" locator="442:24-442:43" path="period" xsi:type="Property">
                        <source localId="913" locator="442:24-442:36" path="repeat" xsi:type="Property">
                           <source localId="912" locator="442:24-442:29" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </operand>
                  </operand>
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="917" locator="442:46-442:69" path="periodUnit" xsi:type="Property">
                        <source localId="916" locator="442:46-442:58" path="repeat" xsi:type="Property">
                           <source localId="915" locator="442:46-442:51" name="timing" xsi:type="QueryLetRef"/>
                        </source>
                     </operand>
                  </operand>
               </expression>
            </let>
            <let localId="922" locator="443:7-443:33" identifier="doseRange">
               <expression localId="921" locator="443:18-443:33" path="dose" xsi:type="Property">
                  <source localId="920" locator="443:18-443:28" name="doseAndRate" xsi:type="QueryLetRef"/>
               </expression>
            </let>
            <let localId="925" locator="444:7-444:36" identifier="doseQuantity">
               <expression localId="924" locator="444:21-444:36" path="dose" xsi:type="Property">
                  <source localId="923" locator="444:21-444:31" name="doseAndRate" xsi:type="QueryLetRef"/>
               </expression>
            </let>
            <let localId="930" locator="445:7-445:52" identifier="dose">
               <expression localId="929" locator="445:13-445:52" xsi:type="Coalesce">
                  <operand localId="927" locator="445:22-445:37" xsi:type="End">
                     <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand asType="fhir:Range" xsi:type="As">
                           <operand localId="926" locator="445:29-445:37" name="doseRange" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand xsi:type="ToQuantity">
                     <operand localId="928" locator="445:40-445:51" name="doseQuantity" xsi:type="QueryLetRef"/>
                  </operand>
               </expression>
            </let>
            <let localId="935" locator="446:7-446:54" identifier="daysSupply">
               <expression localId="934" locator="446:19-446:54" path="value" xsi:type="Property">
                  <source localId="933" locator="446:19-446:48" xsi:type="ConvertQuantity">
                     <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="932" locator="446:28-446:39" path="daysSupply" scope="D" xsi:type="Property"/>
                     </operand>
                     <operand locator="446:44-446:47" valueType="t:String" value="d" xsi:type="Literal"/>
                  </source>
               </expression>
            </let>
            <let localId="945" locator="447:7-447:92" identifier="dosesPerDay">
               <expression localId="944" locator="447:20-447:92" xsi:type="Coalesce">
                  <operand localId="938" locator="447:29-447:54" name="ToDaily" xsi:type="FunctionRef">
                     <operand name="ToInteger" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="936" locator="447:37-447:45" name="frequency" xsi:type="QueryLetRef"/>
                     </operand>
                     <operand localId="937" locator="447:48-447:53" name="period" xsi:type="QueryLetRef"/>
                  </operand>
                  <operand xsi:type="ToDecimal">
                     <operand localId="942" locator="447:57-447:86" xsi:type="Count">
                        <source localId="941" locator="447:63-447:85" path="timeOfDay" xsi:type="Property">
                           <source localId="940" locator="447:63-447:75" path="repeat" xsi:type="Property">
                              <source localId="939" locator="447:63-447:68" name="timing" xsi:type="QueryLetRef"/>
                           </source>
                        </source>
                     </operand>
                  </operand>
                  <operand localId="943" locator="447:89-447:91" valueType="t:Decimal" value="1.0" xsi:type="Literal"/>
               </expression>
            </let>
            <let localId="953" locator="448:7-452:9" identifier="startDate">
               <expression localId="952" locator="449:9-452:9" xsi:type="Coalesce">
                  <operand localId="948" locator="450:11-450:36" xsi:type="DateFrom">
                     <operand name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="947" locator="450:21-450:36" path="whenHandedOver" scope="D" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand localId="951" locator="451:11-451:34" xsi:type="DateFrom">
                     <operand name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="950" locator="451:21-451:34" path="whenPrepared" scope="D" xsi:type="Property"/>
                     </operand>
                  </operand>
               </expression>
            </let>
            <let localId="964" locator="453:7-453:92" identifier="totalDaysSupplied">
               <expression localId="963" locator="453:26-453:92" xsi:type="Coalesce">
                  <operand localId="954" locator="453:35-453:44" name="daysSupply" xsi:type="QueryLetRef"/>
                  <operand localId="962" locator="453:47-453:91" xsi:type="Divide">
                     <operand name="ToDecimal" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="957" locator="453:47-453:62" path="value" xsi:type="Property">
                           <source localId="956" locator="453:47-453:56" path="quantity" scope="D" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand localId="961" locator="453:66-453:91" xsi:type="Multiply">
                        <operand localId="959" locator="453:67-453:76" path="value" xsi:type="Property">
                           <source localId="958" locator="453:67-453:70" name="dose" xsi:type="QueryLetRef"/>
                        </operand>
                        <operand localId="960" locator="453:80-453:90" name="dosesPerDay" xsi:type="QueryLetRef"/>
                     </operand>
                  </operand>
               </expression>
            </let>
            <return localId="981" locator="454:5-458:12">
               <expression localId="980" locator="455:7-458:12" xsi:type="If">
                  <condition localId="969" locator="455:10-455:64" xsi:type="And">
                     <operand localId="966" locator="455:10-455:30" xsi:type="Not">
                        <operand locator="455:10-455:30" xsi:type="IsNull">
                           <operand localId="965" locator="455:10-455:18" name="startDate" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                     <operand localId="968" locator="455:36-455:64" xsi:type="Not">
                        <operand locator="455:36-455:64" xsi:type="IsNull">
                           <operand localId="967" locator="455:36-455:52" name="totalDaysSupplied" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                  </condition>
                  <then localId="978" locator="456:9-456:79" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="970" locator="456:18-456:26" name="startDate" xsi:type="QueryLetRef"/>
                     <high localId="977" locator="456:29-456:78" xsi:type="Add">
                        <operand localId="971" locator="456:29-456:37" name="startDate" xsi:type="QueryLetRef"/>
                        <operand localId="976" locator="456:41-456:78" name="Quantity" xsi:type="FunctionRef">
                           <operand localId="974" locator="456:50-456:70" xsi:type="Subtract">
                              <operand localId="972" locator="456:50-456:66" name="totalDaysSupplied" xsi:type="QueryLetRef"/>
                              <operand xsi:type="ToDecimal">
                                 <operand localId="973" locator="456:70" valueType="t:Integer" value="1" xsi:type="Literal"/>
                              </operand>
                           </operand>
                           <operand localId="975" locator="456:73-456:77" valueType="t:String" value="day" xsi:type="Literal"/>
                        </operand>
                     </high>
                  </then>
                  <else xsi:type="As">
                     <operand localId="979" locator="458:9-458:12" xsi:type="Null"/>
                     <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                        <pointType name="t:Date" xsi:type="NamedTypeSpecifier"/>
                     </asTypeSpecifier>
                  </else>
               </expression>
            </return>
         </expression>
         <operand name="Dispense">
            <operandTypeSpecifier localId="890" locator="435:51-435:70" name="fhir:MedicationDispense" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="986" locator="466:1-467:9" name="TherapeuticDuration" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="986">
               <a:s>/*
Returns the established therapeutic duration for a given medication.
This is likely measure specific, though could potentially be established for
any drug and distributed as a CodeSystem supplement.
Defaulting to 14 days here for illustration.
*/
define function TherapeuticDuration(medication </a:s>
               <a:s r="984">
                  <a:s>Concept</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="985">
                  <a:s r="985">
                     <a:s>14 days</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="985" locator="467:3-467:9" value="14" unit="days" xsi:type="Quantity"/>
         <operand name="medication">
            <operandTypeSpecifier localId="984" locator="466:48-466:54" name="t:Concept" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1015" locator="491:1-500:12" name="MedicationAdministrationPeriod" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1015">
               <a:s>/*
Next we consider MedicationAdministration. This data type is typically used to
capture specific administration, with the relevantPeriod capturing start and stop
time of the administration event:

* effective[x]: Start and end time of administration

However, when calculating cumulative medication duration, it is typically the
therapeutic period of the medication that should be considered. Currently neither
the Medication nor MedicationKnowledge resources provide this information, so
we model it here as a function that can potentially be implemented in a variety
of ways, including measure-specific values, as well as distribution as an RxNorm
code system supplement.

However it is obtained, if therapeutic duration can be obtained, and the effective
period has a start, the result will be

    Interval[startDate, startDate + therapeuticDuration - 1 day]

NOTE: Therapeutic duration needs to be established and until a way is implemented to
do that based on the medication, this logic is incomplete and should not be used.
*/
define function MedicationAdministrationPeriod(Administration </a:s>
               <a:s r="987">
                  <a:s>&quot;MedicationAdministration&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1014">
                  <a:s r="1014">
                     <a:s>
                        <a:s r="989">
                           <a:s r="988">
                              <a:s>
                                 <a:s>Administration</a:s>
                              </a:s>
                           </a:s>
                           <a:s> M</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s>
                        <a:s>let
      </a:s>
                        <a:s r="993">
                           <a:s>therapeuticDuration: </a:s>
                           <a:s r="992">
                              <a:s>TherapeuticDuration(</a:s>
                              <a:s r="991">
                                 <a:s r="990">
                                    <a:s>Administration</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="991">
                                    <a:s>medication</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>,
      </a:s>
                        <a:s r="998">
                           <a:s>startDate: </a:s>
                           <a:s r="997">
                              <a:s>date from </a:s>
                              <a:s r="996">
                                 <a:s>start of </a:s>
                                 <a:s r="995">
                                    <a:s r="994">
                                       <a:s>Administration</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="995">
                                       <a:s>effective</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="1013">
                        <a:s>return
      </a:s>
                        <a:s r="1012">
                           <a:s>if </a:s>
                           <a:s r="1003">
                              <a:s r="1000">
                                 <a:s r="999">
                                    <a:s>startDate</a:s>
                                 </a:s>
                                 <a:s> is not null</a:s>
                              </a:s>
                              <a:s> and </a:s>
                              <a:s r="1002">
                                 <a:s r="1001">
                                    <a:s>therapeuticDuration</a:s>
                                 </a:s>
                                 <a:s> is not null</a:s>
                              </a:s>
                           </a:s>
                           <a:s> then
        </a:s>
                           <a:s r="1010">
                              <a:s>Interval[</a:s>
                              <a:s r="1004">
                                 <a:s>startDate</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="1009">
                                 <a:s r="1007">
                                    <a:s r="1005">
                                       <a:s>startDate</a:s>
                                    </a:s>
                                    <a:s> + </a:s>
                                    <a:s r="1006">
                                       <a:s>therapeuticDuration</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s r="1008"> - 1</a:s>
                              </a:s>
                              <a:s>]</a:s>
                           </a:s>
                           <a:s r="1011">
      else
        null</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1014" locator="492:3-500:12" xsi:type="Query">
            <source localId="989" locator="492:3-492:18" alias="M">
               <expression localId="988" locator="492:3-492:16" name="Administration" xsi:type="OperandRef"/>
            </source>
            <let localId="993" locator="494:7-494:73" identifier="therapeuticDuration">
               <expression localId="992" locator="494:28-494:73" name="TherapeuticDuration" xsi:type="FunctionRef">
                  <operand name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand asType="fhir:CodeableConcept" xsi:type="As">
                        <operand localId="991" locator="494:48-494:72" path="medication" xsi:type="Property">
                           <source localId="990" locator="494:48-494:61" name="Administration" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                  </operand>
               </expression>
            </let>
            <let localId="998" locator="495:7-495:60" identifier="startDate">
               <expression localId="997" locator="495:18-495:60" xsi:type="DateFrom">
                  <operand localId="996" locator="495:28-495:60" xsi:type="Start">
                     <operand name="ToInterval" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand asType="fhir:Period" xsi:type="As">
                           <operand localId="995" locator="495:37-495:60" path="effective" xsi:type="Property">
                              <source localId="994" locator="495:37-495:50" name="Administration" xsi:type="OperandRef"/>
                           </operand>
                        </operand>
                     </operand>
                  </operand>
               </expression>
            </let>
            <return localId="1013" locator="496:5-500:12">
               <expression localId="1012" locator="497:7-500:12" xsi:type="If">
                  <condition localId="1003" locator="497:10-497:66" xsi:type="And">
                     <operand localId="1000" locator="497:10-497:30" xsi:type="Not">
                        <operand locator="497:10-497:30" xsi:type="IsNull">
                           <operand localId="999" locator="497:10-497:18" name="startDate" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                     <operand localId="1002" locator="497:36-497:66" xsi:type="Not">
                        <operand locator="497:36-497:66" xsi:type="IsNull">
                           <operand localId="1001" locator="497:36-497:54" name="therapeuticDuration" xsi:type="QueryLetRef"/>
                        </operand>
                     </operand>
                  </condition>
                  <then localId="1010" locator="498:9-498:64" lowClosed="true" highClosed="true" xsi:type="Interval">
                     <low localId="1004" locator="498:18-498:26" name="startDate" xsi:type="QueryLetRef"/>
                     <high localId="1009" locator="498:29-498:63" xsi:type="Subtract">
                        <operand localId="1007" locator="498:29-498:59" xsi:type="Add">
                           <operand localId="1005" locator="498:29-498:37" name="startDate" xsi:type="QueryLetRef"/>
                           <operand localId="1006" locator="498:41-498:59" name="therapeuticDuration" xsi:type="QueryLetRef"/>
                        </operand>
                        <operand xsi:type="ToQuantity">
                           <operand localId="1008" locator="498:63" valueType="t:Integer" value="1" xsi:type="Literal"/>
                        </operand>
                     </high>
                  </then>
                  <else xsi:type="As">
                     <operand localId="1011" locator="500:9-500:12" xsi:type="Null"/>
                     <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                        <pointType name="t:Date" xsi:type="NamedTypeSpecifier"/>
                     </asTypeSpecifier>
                  </else>
               </expression>
            </return>
         </expression>
         <operand name="Administration">
            <operandTypeSpecifier localId="987" locator="491:63-491:88" name="fhir:MedicationAdministration" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="1036" locator="516:1-523:13" name="CumulativeDuration" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1036">
               <a:s>/*
Now that we have functions for determining the medication period for individual
prescriptions, administrations, and dispenses, we can combine those using
an overall cumulative medication duration calculation.

There are two broad approaches to calculating cumulative duration, one that _collapses_
overlapping intervals so that calculations are not duplicated, and one that _rolls out_
overlapping intervals so that the durations are laid end-to-end.

First, we define a function that simply calculates CumulativeDuration of a set of
intervals:

NOTE: Updated argument to List&lt;Interval&lt;Date>> instead of List&lt;Interval&lt;DateTime>>
*/
define function CumulativeDuration(Intervals </a:s>
               <a:s r="1018">
                  <a:s>List&lt;</a:s>
                  <a:s r="1017">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="1016">
                        <a:s>Date</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
   </a:s>
               <a:s r="1035">
                  <a:s r="1035">
                     <a:s>if </a:s>
                     <a:s r="1020">
                        <a:s r="1019">
                           <a:s>Intervals</a:s>
                        </a:s>
                        <a:s> is not null</a:s>
                     </a:s>
                     <a:s> then </a:s>
                     <a:s r="1033">
                        <a:s>( </a:s>
                        <a:s r="1033">
                           <a:s>Sum(</a:s>
                           <a:s r="1032">
                              <a:s>
                                 <a:s r="1023">
                                    <a:s r="1022">
                                       <a:s>(</a:s>
                                       <a:s r="1022">
                                          <a:s>collapse </a:s>
                                          <a:s r="1021">
                                             <a:s>Intervals</a:s>
                                          </a:s>
                                          <a:s> per day</a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                    <a:s>X</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
        </a:s>
                              <a:s r="1031">
                                 <a:s>return all</a:s>
                                 <a:s r="1030">
                                    <a:s r="1028">
                                       <a:s>(</a:s>
                                       <a:s r="1028">
                                          <a:s>difference in days between </a:s>
                                          <a:s r="1025">
                                             <a:s>start of </a:s>
                                             <a:s r="1024">
                                                <a:s>X</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> and 
          </a:s>
                                          <a:s r="1027">
                                             <a:s>end of </a:s>
                                             <a:s r="1026">
                                                <a:s>X</a:s>
                                             </a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>
        )</a:s>
                                    </a:s>
                                    <a:s r="1029">+ 1</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    )</a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                     <a:s r="1034"> 
    else null</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1035" locator="517:4-523:13" xsi:type="If">
            <condition localId="1020" locator="517:7-517:27" xsi:type="Not">
               <operand locator="517:7-517:27" xsi:type="IsNull">
                  <operand localId="1019" locator="517:7-517:15" name="Intervals" xsi:type="OperandRef"/>
               </operand>
            </condition>
            <then localId="1033" locator="517:34-522:3" xsi:type="Sum">
               <source localId="1032" locator="517:40-520:12" xsi:type="Query">
                  <source localId="1023" locator="517:40-517:68" alias="X">
                     <expression localId="1022" locator="517:40-517:67" xsi:type="Collapse">
                        <operand localId="1021" locator="517:50-517:58" name="Intervals" xsi:type="OperandRef"/>
                        <operand value="1.0" unit="day" xsi:type="Quantity"/>
                     </expression>
                  </source>
                  <return localId="1031" locator="518:9-520:12" distinct="false">
                     <expression localId="1030" locator="518:19-520:12" xsi:type="Add">
                        <operand localId="1028" locator="518:19-520:9" precision="Day" xsi:type="DifferenceBetween">
                           <operand localId="1025" locator="518:47-518:56" xsi:type="Start">
                              <operand localId="1024" locator="518:56" name="X" xsi:type="AliasRef"/>
                           </operand>
                           <operand localId="1027" locator="519:11-519:18" xsi:type="End">
                              <operand localId="1026" locator="519:18" name="X" xsi:type="AliasRef"/>
                           </operand>
                        </operand>
                        <operand localId="1029" locator="520:12" valueType="t:Integer" value="1" xsi:type="Literal"/>
                     </expression>
                  </return>
               </source>
            </then>
            <else asType="t:Integer" xsi:type="As">
               <operand localId="1034" locator="523:10-523:13" xsi:type="Null"/>
            </else>
         </expression>
         <operand name="Intervals">
            <operandTypeSpecifier localId="1018" locator="516:46-516:65" xsi:type="ListTypeSpecifier">
               <elementType localId="1017" locator="516:51-516:64" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="1016" locator="516:60-516:63" name="t:Date" xsi:type="NamedTypeSpecifier"/>
               </elementType>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1078" locator="530:1-538:5" name="RolloutIntervals" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1078">
               <a:s>/*
Next, we define a function that rolls out intervals:

NOTE: Updated argument to List&lt;Interval&lt;Date>> instead of List&lt;Interval&lt;DateTime>>
*/
define function RolloutIntervals(intervals </a:s>
               <a:s r="1039">
                  <a:s>List&lt;</a:s>
                  <a:s r="1038">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="1037">
                        <a:s>Date</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
 </a:s>
               <a:s r="1077">
                  <a:s r="1077">
                     <a:s>
                        <a:s r="1041">
                           <a:s r="1040">
                              <a:s>
                                 <a:s>intervals</a:s>
                              </a:s>
                           </a:s>
                           <a:s> I</a:s>
                        </a:s>
                     </a:s>
                     <a:s> </a:s>
                     <a:s r="1076">
                        <a:s>aggregate all R </a:s>
                        <a:s r="1046">
                           <a:s>starting ( </a:s>
                           <a:s r="1046">
                              <a:s r="1042">null as </a:s>
                              <a:s r="1045">
                                 <a:s>List&lt;</a:s>
                                 <a:s r="1044">
                                    <a:s>Interval&lt;</a:s>
                                    <a:s r="1043">
                                       <a:s>Date</a:s>
                                    </a:s>
                                    <a:s>></a:s>
                                 </a:s>
                                 <a:s>></a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s>: </a:s>
                        <a:s r="1075">
                           <a:s r="1047">
                              <a:s>R</a:s>
                           </a:s>
                           <a:s>
    union </a:s>
                           <a:s r="1074">
                              <a:s>( </a:s>
                              <a:s r="1074">
                                 <a:s>{ </a:s>
                                 <a:s r="1073">
                                    <a:s>
                                       <a:s r="1049">
                                          <a:s r="1048">
                                             <a:s>
                                                <a:s>I</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> X</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s>
                                       <a:s>let </a:s>
                                       <a:s r="1059">
                                          <a:s>S: </a:s>
                                          <a:s r="1058">
                                             <a:s>Max(</a:s>
                                             <a:s r="1057">
                                                <a:s>{ 
          </a:s>
                                                <a:s r="1054">
                                                   <a:s r="1052">
                                                      <a:s>end of </a:s>
                                                      <a:s r="1051">
                                                         <a:s>Last(</a:s>
                                                         <a:s r="1050">
                                                            <a:s>R</a:s>
                                                         </a:s>
                                                         <a:s>)</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>+ </a:s>
                                                   <a:s r="1053">
                                                      <a:s>1 day</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>, </a:s>
                                                <a:s r="1056">
                                                   <a:s>start of </a:s>
                                                   <a:s r="1055">
                                                      <a:s>X</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s> }</a:s>
                                             </a:s>
                                             <a:s>
        )</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>,
        </a:s>
                                       <a:s r="1068">
                                          <a:s>E: </a:s>
                                          <a:s r="1067">
                                             <a:s r="1060">
                                                <a:s>S</a:s>
                                             </a:s>
                                             <a:s> + </a:s>
                                             <a:s r="1066">
                                                <a:s>Quantity(</a:s>
                                                <a:s r="1064">
                                                   <a:s>Coalesce(</a:s>
                                                   <a:s r="1062">
                                                      <a:s>duration in days of </a:s>
                                                      <a:s r="1061">
                                                         <a:s>X</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s r="1063">, 0)</a:s>
                                                </a:s>
                                                <a:s>, </a:s>
                                                <a:s r="1065">
                                                   <a:s>'day'</a:s>
                                                </a:s>
                                                <a:s>)</a:s>
                                             </a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="1072">
                                       <a:s>return </a:s>
                                       <a:s r="1071">
                                          <a:s>Interval[</a:s>
                                          <a:s r="1069">
                                             <a:s>S</a:s>
                                          </a:s>
                                          <a:s>, </a:s>
                                          <a:s r="1070">
                                             <a:s>E</a:s>
                                          </a:s>
                                          <a:s>]</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>}</a:s>
                              </a:s>
                              <a:s>
    )</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1077" locator="531:2-538:5" xsi:type="Query">
            <source localId="1041" locator="531:2-531:12" alias="I">
               <expression localId="1040" locator="531:2-531:10" name="intervals" xsi:type="OperandRef"/>
            </source>
            <aggregate localId="1076" locator="531:14-538:5" identifier="R" distinct="false">
               <expression localId="1075" locator="531:72-538:5" xsi:type="Union">
                  <operand localId="1047" locator="531:72" name="R" xsi:type="QueryLetRef"/>
                  <operand localId="1074" locator="532:11-538:5" xsi:type="List">
                     <element localId="1073" locator="532:15-537:29" xsi:type="Query">
                        <source localId="1049" locator="532:15-532:17" alias="X">
                           <expression localId="1048" locator="532:15" name="I" xsi:type="AliasRef"/>
                        </source>
                        <let localId="1059" locator="533:13-535:9" identifier="S">
                           <expression localId="1058" locator="533:16-535:9" xsi:type="Max">
                              <source localId="1057" locator="533:20-534:45" xsi:type="List">
                                 <element localId="1054" locator="534:11-534:31" xsi:type="Add">
                                    <operand localId="1052" locator="534:11-534:24" xsi:type="End">
                                       <operand localId="1051" locator="534:18-534:24" xsi:type="Last">
                                          <source localId="1050" locator="534:23" name="R" xsi:type="QueryLetRef"/>
                                       </operand>
                                    </operand>
                                    <operand localId="1053" locator="534:27-534:31" value="1" unit="day" xsi:type="Quantity"/>
                                 </element>
                                 <element localId="1056" locator="534:34-534:43" xsi:type="Start">
                                    <operand localId="1055" locator="534:43" name="X" xsi:type="AliasRef"/>
                                 </element>
                              </source>
                           </expression>
                        </let>
                        <let localId="1068" locator="536:9-536:66" identifier="E">
                           <expression localId="1067" locator="536:12-536:66" xsi:type="Add">
                              <operand localId="1060" locator="536:12" name="S" xsi:type="QueryLetRef"/>
                              <operand localId="1066" locator="536:16-536:66" name="Quantity" xsi:type="FunctionRef">
                                 <operand xsi:type="ToDecimal">
                                    <operand localId="1064" locator="536:25-536:58" xsi:type="Coalesce">
                                       <operand localId="1062" locator="536:34-536:54" precision="Day" xsi:type="DurationBetween">
                                          <operand xsi:type="Start">
                                             <operand localId="1061" locator="536:54" name="X" xsi:type="AliasRef"/>
                                          </operand>
                                          <operand xsi:type="End">
                                             <operand localId="1061" locator="536:54" name="X" xsi:type="AliasRef"/>
                                          </operand>
                                       </operand>
                                       <operand localId="1063" locator="536:57" valueType="t:Integer" value="0" xsi:type="Literal"/>
                                    </operand>
                                 </operand>
                                 <operand localId="1065" locator="536:61-536:65" valueType="t:String" value="day" xsi:type="Literal"/>
                              </operand>
                           </expression>
                        </let>
                        <return localId="1072" locator="537:9-537:29">
                           <expression localId="1071" locator="537:16-537:29" lowClosed="true" highClosed="true" xsi:type="Interval">
                              <low localId="1069" locator="537:25" name="S" xsi:type="QueryLetRef"/>
                              <high localId="1070" locator="537:28" name="E" xsi:type="QueryLetRef"/>
                           </expression>
                        </return>
                     </element>
                  </operand>
               </expression>
               <starting localId="1046" locator="531:30-531:69" strict="false" xsi:type="As">
                  <operand localId="1042" locator="531:41-531:44" xsi:type="Null"/>
                  <asTypeSpecifier localId="1045" locator="531:49-531:68" xsi:type="ListTypeSpecifier">
                     <elementType localId="1044" locator="531:54-531:67" xsi:type="IntervalTypeSpecifier">
                        <pointType localId="1043" locator="531:63-531:66" name="t:Date" xsi:type="NamedTypeSpecifier"/>
                     </elementType>
                  </asTypeSpecifier>
               </starting>
            </aggregate>
         </expression>
         <operand name="intervals">
            <operandTypeSpecifier localId="1039" locator="530:44-530:63" xsi:type="ListTypeSpecifier">
               <elementType localId="1038" locator="530:49-530:62" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="1037" locator="530:58-530:61" name="t:Date" xsi:type="NamedTypeSpecifier"/>
               </elementType>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1096" locator="545:1-553:5" name="MedicationPeriod" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1096">
               <a:s>/*
Then, we define a function that allows us to calculate based on the various medication
types:
*/
define function MedicationPeriod(
  medication </a:s>
               <a:s r="1081">
                  <a:s>Choice&lt;</a:s>
                  <a:s r="1079">
                     <a:s>USCore.&quot;MedicationRequestProfile&quot;</a:s>
                  </a:s>
                  <a:s>,
    </a:s>
                  <a:s r="1080">
                     <a:s>&quot;MedicationDispense&quot;</a:s>
                  </a:s>
                  <a:s>
  ></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1095">
                  <a:s r="1095">
                     <a:s>case
    </a:s>
                     <a:s r="1087">
                        <a:s>when </a:s>
                        <a:s r="1084">
                           <a:s r="1082">
                              <a:s>medication</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="1083">
                              <a:s>USCore.&quot;MedicationRequestProfile&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="1086">
                           <a:s>MedicationRequestPeriod(</a:s>
                           <a:s r="1085">
                              <a:s>medication</a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="1093">
                        <a:s>when </a:s>
                        <a:s r="1090">
                           <a:s r="1088">
                              <a:s>medication</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="1089">
                              <a:s>MedicationDispense</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then </a:s>
                        <a:s r="1092">
                           <a:s>MedicationDispensePeriod(</a:s>
                           <a:s r="1091">
                              <a:s>medication</a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s r="1094">
    else null
  end</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1095" locator="549:3-553:5" xsi:type="Case">
            <caseItem localId="1087" locator="550:5-550:97">
               <when localId="1084" locator="550:10-550:56" xsi:type="Is">
                  <operand localId="1082" locator="550:10-550:19" name="medication" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="1083" locator="550:24-550:56" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="1086" locator="550:63-550:97" name="MedicationRequestPeriod" xsi:type="FunctionRef">
                  <operand asType="fhir:MedicationRequest" xsi:type="As">
                     <operand localId="1085" locator="550:87-550:96" name="medication" xsi:type="OperandRef"/>
                  </operand>
               </then>
            </caseItem>
            <caseItem localId="1093" locator="551:5-551:83">
               <when localId="1090" locator="551:10-551:41" xsi:type="Is">
                  <operand localId="1088" locator="551:10-551:19" name="medication" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="1089" locator="551:24-551:41" name="fhir:MedicationDispense" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="1092" locator="551:48-551:83" name="MedicationDispensePeriod" xsi:type="FunctionRef">
                  <operand asType="fhir:MedicationDispense" xsi:type="As">
                     <operand localId="1091" locator="551:73-551:82" name="medication" xsi:type="OperandRef"/>
                  </operand>
               </then>
            </caseItem>
            <else xsi:type="As">
               <operand localId="1094" locator="552:10-552:13" xsi:type="Null"/>
               <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                  <pointType name="t:Date" xsi:type="NamedTypeSpecifier"/>
               </asTypeSpecifier>
            </else>
         </expression>
         <operand name="medication">
            <operandTypeSpecifier localId="1081" locator="546:14-548:3" xsi:type="ChoiceTypeSpecifier">
               <choice localId="1079" locator="546:21-546:53" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
               <choice localId="1080" locator="547:5-547:24" name="fhir:MedicationDispense" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1122" locator="569:1-585:3" name="CumulativeMedicationDuration" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1122">
               <a:s>/*
We can then use this function, combined with the MedicationDuration functions above
to calculate Cumulative Medication Duration:

Generally speaking, we want to _roll out_ intervals from dispense and administration
events, and then collapse across that result and intervals from prescriptions.

Note also that the separation of medications by type should already be done
by this stage as well.

Calculations that combine dosages from different types of medications (such as Morphine Milligram Equivalent (MME)
or Average MME) require further consideration.
*/
define function CumulativeMedicationDuration(
  Medications </a:s>
               <a:s r="1100">
                  <a:s>List&lt;</a:s>
                  <a:s r="1099">
                     <a:s>Choice&lt;</a:s>
                     <a:s r="1097">
                        <a:s>USCore.&quot;MedicationRequestProfile&quot;</a:s>
                     </a:s>
                     <a:s>,
    </a:s>
                     <a:s r="1098">
                        <a:s>&quot;MedicationDispense&quot;</a:s>
                     </a:s>
                     <a:s>
  ></a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1121">
                  <a:s r="1121">
                     <a:s>CumulativeDuration(</a:s>
                     <a:s r="1120">
                        <a:s r="1109">
                           <a:s>(
      </a:s>
                           <a:s r="1109">
                              <a:s>
                                 <a:s r="1102">
                                    <a:s r="1101">
                                       <a:s>
                                          <a:s>Medications</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> M</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
        </a:s>
                              <a:s r="1105">
                                 <a:s>where </a:s>
                                 <a:s r="1105">
                                    <a:s r="1103">
                                       <a:s>M</a:s>
                                    </a:s>
                                    <a:s> is </a:s>
                                    <a:s r="1104">
                                       <a:s>MedicationRequest</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
        </a:s>
                              <a:s r="1108">
                                 <a:s>return </a:s>
                                 <a:s r="1107">
                                    <a:s>MedicationRequestPeriod(</a:s>
                                    <a:s r="1106">
                                       <a:s>M</a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    )</a:s>
                        </a:s>
                        <a:s>
      union </a:s>
                        <a:s r="1119">
                           <a:s>(
        </a:s>
                           <a:s r="1119">
                              <a:s>RolloutIntervals(
          </a:s>
                              <a:s r="1118">
                                 <a:s>
                                    <a:s r="1111">
                                       <a:s r="1110">
                                          <a:s>
                                             <a:s>Medications</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> M</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
            </a:s>
                                 <a:s r="1114">
                                    <a:s>where </a:s>
                                    <a:s r="1114">
                                       <a:s r="1112">
                                          <a:s>M</a:s>
                                       </a:s>
                                       <a:s> is </a:s>
                                       <a:s r="1113">
                                          <a:s>MedicationDispense</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
            </a:s>
                                 <a:s r="1117">
                                    <a:s>return </a:s>
                                    <a:s r="1116">
                                       <a:s>MedicationDispensePeriod(</a:s>
                                       <a:s r="1115">
                                          <a:s>M</a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
        )</a:s>
                           </a:s>
                           <a:s>
      )</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1121" locator="573:3-585:3" name="CumulativeDuration" xsi:type="FunctionRef">
            <operand localId="1120" locator="573:22-584:7" xsi:type="Union">
               <operand localId="1109" locator="573:22-577:5" xsi:type="Query">
                  <source localId="1102" locator="574:7-574:19" alias="M">
                     <expression localId="1101" locator="574:7-574:17" name="Medications" xsi:type="OperandRef"/>
                  </source>
                  <where localId="1105" locator="575:9-575:36" xsi:type="Is">
                     <operand localId="1103" locator="575:15" name="M" xsi:type="AliasRef"/>
                     <isTypeSpecifier localId="1104" locator="575:20-575:36" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
                  </where>
                  <return localId="1108" locator="576:9-576:41">
                     <expression localId="1107" locator="576:16-576:41" name="MedicationRequestPeriod" xsi:type="FunctionRef">
                        <operand asType="fhir:MedicationRequest" xsi:type="As">
                           <operand localId="1106" locator="576:40" name="M" xsi:type="AliasRef"/>
                        </operand>
                     </expression>
                  </return>
               </operand>
               <operand localId="1119" locator="578:13-584:7" name="RolloutIntervals" xsi:type="FunctionRef">
                  <operand localId="1118" locator="580:11-582:46" xsi:type="Query">
                     <source localId="1111" locator="580:11-580:23" alias="M">
                        <expression localId="1110" locator="580:11-580:21" name="Medications" xsi:type="OperandRef"/>
                     </source>
                     <where localId="1114" locator="581:13-581:41" xsi:type="Is">
                        <operand localId="1112" locator="581:19" name="M" xsi:type="AliasRef"/>
                        <isTypeSpecifier localId="1113" locator="581:24-581:41" name="fhir:MedicationDispense" xsi:type="NamedTypeSpecifier"/>
                     </where>
                     <return localId="1117" locator="582:13-582:46">
                        <expression localId="1116" locator="582:20-582:46" name="MedicationDispensePeriod" xsi:type="FunctionRef">
                           <operand asType="fhir:MedicationDispense" xsi:type="As">
                              <operand localId="1115" locator="582:45" name="M" xsi:type="AliasRef"/>
                           </operand>
                        </expression>
                     </return>
                  </operand>
               </operand>
            </operand>
         </expression>
         <operand name="Medications">
            <operandTypeSpecifier localId="1100" locator="570:15-572:4" xsi:type="ListTypeSpecifier">
               <elementType localId="1099" locator="570:20-572:3" xsi:type="ChoiceTypeSpecifier">
                  <choice localId="1097" locator="570:27-570:59" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
                  <choice localId="1098" locator="571:5-571:24" name="fhir:MedicationDispense" xsi:type="NamedTypeSpecifier"/>
               </elementType>
            </operandTypeSpecifier>
         </operand>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorVersion" : "2.7.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "t" : [ {
            "name" : "description",
            "value" : "This library provides cumulative medication duration calculation\nlogic for use with FHIR medication prescription, administration, and dispensing\nresources. The logic here follows the guidance provided as part of the 5.6\nversion of Quality Data Model."
         }, {
            "name" : "comment",
            "value" : "Note that the logic here assumes single-instruction dosing information.\nSplit-dosing, tapering, and other more complex dosing instructions are not handled."
         }, {
            "name" : "update",
            "value" : "v0.2.000\nFixed Quantity handling in duration calculations\nFixed authorDatetime null handling\nChanged to provide Date-level calculation, rather than DateTime\nv2.0.000\nUpdated as part of 2022 AU refresh\nRefactored to use QICoreCommon\nv2.0.001\nFixed invalid unit error evaluating RolloutIntervals\nFixed RolloutIntervals incorrectly eliminating duplicates\nv3.1.000\nupdated to reflect changes from AU2022 QDM library changes _JKR"
         } ],
         "s" : {
            "r" : "1125",
            "s" : [ {
               "value" : [ "/* \n@description: This library provides cumulative medication duration calculation\nlogic for use with FHIR medication prescription, administration, and dispensing\nresources. The logic here follows the guidance provided as part of the 5.6\nversion of Quality Data Model.\n@comment: Note that the logic here assumes single-instruction dosing information.\nSplit-dosing, tapering, and other more complex dosing instructions are not handled.\n@update:\nv0.2.000\nFixed Quantity handling in duration calculations\nFixed authorDatetime null handling\nChanged to provide Date-level calculation, rather than DateTime\nv2.0.000\nUpdated as part of 2022 AU refresh\nRefactored to use QICoreCommon\nv2.0.001\nFixed invalid unit error evaluating RolloutIntervals\nFixed RolloutIntervals incorrectly eliminating duplicates\nv3.1.000\nupdated to reflect changes from AU2022 QDM library changes _JKR\n*/\n","library CumulativeMedicationDuration version '3.1.000'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "CumulativeMedicationDuration",
         "system" : "http://fhir.org/guides/cqf/us/common",
         "version" : "3.1.000"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "24:1-24:28",
            "localIdentifier" : "USCore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCore" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.1.1'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "2",
            "locator" : "27:1-27:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "2",
                  "s" : [ {
                     "value" : [ "// NOTE: Including FHIR to handle MedicationDispense and MedicationAdministration (not in USCore 3.1.1)\n// TODO: Remove this reference once USCore supports MedicationDispense and MedicationAdministration\n","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIR" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.0.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "34:1-34:37",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/cqf/us/common/FHIRHelpers",
            "version" : "4.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "3",
                  "s" : [ {
                     "value" : [ "// NOTE: Removed in favor of USCore version '3.1.1'\n//using QICore version '4.1.1'\n\n// NOTE: Updated to 4.0.1 for now to simplify dependencies\n// NOTE: include FHIRHelpers version '4.2.000'\n","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.1.000'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "4",
            "locator" : "38:1-38:36",
            "localIdentifier" : "USCoreCommon",
            "path" : "http://fhir.org/guides/cqf/us/common/USCoreCommon",
            "version" : "0.1.0",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "4",
                  "s" : [ {
                     "value" : [ "// NOTE: Removed in favor of USCoreCommon\n//include QICoreCommon version '1.3.000'\n","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'0.1.0'" ]
                  } ]
               }
            } ]
         } ]
      },
      "parameters" : {
         "def" : [ {
            "localId" : "105",
            "locator" : "95:1-95:45",
            "name" : "ErrorLevel",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "105",
                  "s" : [ {
                     "value" : [ "","parameter ","ErrorLevel"," " ]
                  }, {
                     "r" : "104",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ " default " ]
                  }, {
                     "r" : "103",
                     "s" : [ {
                        "value" : [ "'Warning'" ]
                     } ]
                  } ]
               }
            } ],
            "default" : {
               "localId" : "103",
               "locator" : "95:37-95:45",
               "valueType" : "{urn:hl7-org:elm-types:r1}String",
               "value" : "Warning",
               "type" : "Literal"
            },
            "parameterTypeSpecifier" : {
               "localId" : "104",
               "locator" : "95:22-95:27",
               "name" : "{urn:hl7-org:elm-types:r1}String",
               "type" : "NamedTypeSpecifier"
            }
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "5",
            "locator" : "41:1-41:82",
            "name" : "V3TimingEvent",
            "id" : "http://terminology.hl7.org/CodeSystem/v3-TimingEvent",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "5",
                  "s" : [ {
                     "value" : [ "// These code systems are not known to the MAT environment yet, request to have them added submitted\n","codesystem ","\"V3TimingEvent\"",": ","'http://terminology.hl7.org/CodeSystem/v3-TimingEvent'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "6",
            "locator" : "42:1-42:60",
            "name" : "EventTiming",
            "id" : "http://hl7.org/fhir/event-timing",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "6",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"EventTiming\"",": ","'http://hl7.org/fhir/event-timing'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "8",
            "locator" : "44:1-44:36",
            "name" : "HS",
            "id" : "HS",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "8",
                  "s" : [ {
                     "value" : [ "","code ","\"HS\"",": ","'HS'"," from " ]
                  }, {
                     "r" : "7",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "7",
               "locator" : "44:22-44:36",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "10",
            "locator" : "45:1-45:40",
            "name" : "WAKE",
            "id" : "WAKE",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "10",
                  "s" : [ {
                     "value" : [ "// event occurs [offset] before the hour of sleep (or trying to)\n","code ","\"WAKE\"",": ","'WAKE'"," from " ]
                  }, {
                     "r" : "9",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "9",
               "locator" : "45:26-45:40",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "12",
            "locator" : "46:1-46:34",
            "name" : "C",
            "id" : "C",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "12",
                  "s" : [ {
                     "value" : [ "// event occurs [offset] after waking\n","code ","\"C\"",": ","'C'"," from " ]
                  }, {
                     "r" : "11",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "11",
               "locator" : "46:20-46:34",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "14",
            "locator" : "47:1-47:36",
            "name" : "CM",
            "id" : "CM",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "14",
                  "s" : [ {
                     "value" : [ "//\tevent occurs at a meal (from the Latin cibus)\n","code ","\"CM\"",": ","'CM'"," from " ]
                  }, {
                     "r" : "13",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "13",
               "locator" : "47:22-47:36",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "16",
            "locator" : "48:1-48:36",
            "name" : "CD",
            "id" : "CD",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "16",
                  "s" : [ {
                     "value" : [ "//\tevent occurs at breakfast (from the Latin cibus matutinus)\n","code ","\"CD\"",": ","'CD'"," from " ]
                  }, {
                     "r" : "15",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "15",
               "locator" : "48:22-48:36",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "18",
            "locator" : "49:1-49:36",
            "name" : "CV",
            "id" : "CV",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "18",
                  "s" : [ {
                     "value" : [ "//\tevent occurs at lunch (from the Latin cibus diurnus)\n","code ","\"CV\"",": ","'CV'"," from " ]
                  }, {
                     "r" : "17",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "17",
               "locator" : "49:22-49:36",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "20",
            "locator" : "50:1-50:36",
            "name" : "AC",
            "id" : "AC",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "20",
                  "s" : [ {
                     "value" : [ "//\tevent occurs at dinner (from the Latin ante cibus vespertinus)\n","code ","\"AC\"",": ","'AC'"," from " ]
                  }, {
                     "r" : "19",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "19",
               "locator" : "50:22-50:36",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "22",
            "locator" : "51:1-51:38",
            "name" : "ACM",
            "id" : "ACM",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "22",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] before a meal (from the Latin ante cibus)\n","code ","\"ACM\"",": ","'ACM'"," from " ]
                  }, {
                     "r" : "21",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "21",
               "locator" : "51:24-51:38",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "24",
            "locator" : "52:1-52:38",
            "name" : "ACD",
            "id" : "ACD",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "24",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] before breakfast (from the Latin ante cibus matutinus)\n","code ","\"ACD\"",": ","'ACD'"," from " ]
                  }, {
                     "r" : "23",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "23",
               "locator" : "52:24-52:38",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "26",
            "locator" : "53:1-53:38",
            "name" : "ACV",
            "id" : "ACV",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "26",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] before lunch (from the Latin ante cibus diurnus)\n","code ","\"ACV\"",": ","'ACV'"," from " ]
                  }, {
                     "r" : "25",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "25",
               "locator" : "53:24-53:38",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "28",
            "locator" : "54:1-54:36",
            "name" : "PC",
            "id" : "PC",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "28",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] before dinner (from the Latin ante cibus vespertinus)\n","code ","\"PC\"",": ","'PC'"," from " ]
                  }, {
                     "r" : "27",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "27",
               "locator" : "54:22-54:36",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "30",
            "locator" : "55:1-55:38",
            "name" : "PCM",
            "id" : "PCM",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "30",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] after a meal (from the Latin post cibus)\n","code ","\"PCM\"",": ","'PCM'"," from " ]
                  }, {
                     "r" : "29",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "29",
               "locator" : "55:24-55:38",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "32",
            "locator" : "56:1-56:38",
            "name" : "PCD",
            "id" : "PCD",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "32",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] after breakfast (from the Latin post cibus matutinus)\n","code ","\"PCD\"",": ","'PCD'"," from " ]
                  }, {
                     "r" : "31",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "31",
               "locator" : "56:24-56:38",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "34",
            "locator" : "57:1-57:38",
            "name" : "PCV",
            "id" : "PCV",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "34",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] after lunch (from the Latin post cibus diurnus)\n","code ","\"PCV\"",": ","'PCV'"," from " ]
                  }, {
                     "r" : "33",
                     "s" : [ {
                        "value" : [ "\"V3TimingEvent\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "33",
               "locator" : "57:24-57:38",
               "name" : "V3TimingEvent"
            }
         }, {
            "localId" : "36",
            "locator" : "59:1-59:36",
            "name" : "MORN",
            "id" : "MORN",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "36",
                  "s" : [ {
                     "value" : [ "//\tevent occurs [offset] after dinner (from the Latin post cibus vespertinus)\n","code ","\"MORN\"",": ","'MORN'"," from " ]
                  }, {
                     "r" : "35",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "35",
               "locator" : "59:26-59:36",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "38",
            "locator" : "60:1-60:48",
            "name" : "MORN.early",
            "id" : "MORN.early",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "38",
                  "s" : [ {
                     "value" : [ "//\tEvent occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"MORN.early\"",": ","'MORN.early'"," from " ]
                  }, {
                     "r" : "37",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "37",
               "locator" : "60:38-60:48",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "40",
            "locator" : "61:1-61:46",
            "name" : "MORN.late",
            "id" : "MORN.late",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "40",
                  "s" : [ {
                     "value" : [ "//\tEarly Morning\tEvent occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"MORN.late\"",": ","'MORN.late'"," from " ]
                  }, {
                     "r" : "39",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "39",
               "locator" : "61:36-61:46",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "42",
            "locator" : "62:1-62:36",
            "name" : "NOON",
            "id" : "NOON",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "42",
                  "s" : [ {
                     "value" : [ "// Late Morning\tEvent occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"NOON\"",": ","'NOON'"," from " ]
                  }, {
                     "r" : "41",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "41",
               "locator" : "62:26-62:36",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "44",
            "locator" : "63:1-63:34",
            "name" : "AFT",
            "id" : "AFT",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "44",
                  "s" : [ {
                     "value" : [ "//\tNoon\tEvent occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"AFT\"",": ","'AFT'"," from " ]
                  }, {
                     "r" : "43",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "43",
               "locator" : "63:24-63:34",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "46",
            "locator" : "64:1-64:46",
            "name" : "AFT.early",
            "id" : "AFT.early",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "46",
                  "s" : [ {
                     "value" : [ "//\tAfternoon\tEvent occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"AFT.early\"",": ","'AFT.early'"," from " ]
                  }, {
                     "r" : "45",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "45",
               "locator" : "64:36-64:46",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "48",
            "locator" : "65:1-65:44",
            "name" : "AFT.late",
            "id" : "AFT.late",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "48",
                  "s" : [ {
                     "value" : [ "//\tEarly Afternoon\tEvent occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"AFT.late\"",": ","'AFT.late'"," from " ]
                  }, {
                     "r" : "47",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "47",
               "locator" : "65:34-65:44",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "50",
            "locator" : "66:1-66:34",
            "name" : "EVE",
            "id" : "EVE",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "50",
                  "s" : [ {
                     "value" : [ "//\tLate Afternoon\tEvent occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"EVE\"",": ","'EVE'"," from " ]
                  }, {
                     "r" : "49",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "49",
               "locator" : "66:24-66:34",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "52",
            "locator" : "67:1-67:46",
            "name" : "EVE.early",
            "id" : "EVE.early",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "52",
                  "s" : [ {
                     "value" : [ "//\tEvening\tEvent occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"EVE.early\"",": ","'EVE.early'"," from " ]
                  }, {
                     "r" : "51",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "51",
               "locator" : "67:36-67:46",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "54",
            "locator" : "68:1-68:44",
            "name" : "EVE.late",
            "id" : "EVE.late",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "54",
                  "s" : [ {
                     "value" : [ "//\tEarly Evening\tEvent occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"EVE.late\"",": ","'EVE.late'"," from " ]
                  }, {
                     "r" : "53",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "53",
               "locator" : "68:34-68:44",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "56",
            "locator" : "69:1-69:38",
            "name" : "NIGHT",
            "id" : "NIGHT",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "56",
                  "s" : [ {
                     "value" : [ "//\tLate Evening\tEvent occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"NIGHT\"",": ","'NIGHT'"," from " ]
                  }, {
                     "r" : "55",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "55",
               "locator" : "69:28-69:38",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "58",
            "locator" : "70:1-70:34",
            "name" : "PHS",
            "id" : "PHS",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "58",
                  "s" : [ {
                     "value" : [ "//\tNight\tEvent occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"PHS\"",": ","'PHS'"," from " ]
                  }, {
                     "r" : "57",
                     "s" : [ {
                        "value" : [ "EventTiming" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "57",
               "locator" : "70:24-70:34",
               "name" : "EventTiming"
            }
         }, {
            "localId" : "60",
            "locator" : "72:1-72:130",
            "name" : "Every eight hours (qualifier value)",
            "id" : "307469008",
            "display" : "Every eight hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "60",
                  "s" : [ {
                     "value" : [ "//\tAfter Sleep\tEvent occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation.\n","code ","\"Every eight hours (qualifier value)\"",": ","'307469008'"," from " ]
                  }, {
                     "r" : "59",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every eight hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "59",
               "locator" : "72:62-72:84",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "62",
            "locator" : "73:1-73:150",
            "name" : "Every eight to twelve hours (qualifier value)",
            "id" : "396140003",
            "display" : "Every eight to twelve hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "62",
                  "s" : [ {
                     "value" : [ "","code ","\"Every eight to twelve hours (qualifier value)\"",": ","'396140003'"," from " ]
                  }, {
                     "r" : "61",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every eight to twelve hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "61",
               "locator" : "73:72-73:94",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "64",
            "locator" : "74:1-74:142",
            "name" : "Every forty eight hours (qualifier value)",
            "id" : "396131002",
            "display" : "Every forty eight hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "64",
                  "s" : [ {
                     "value" : [ "","code ","\"Every forty eight hours (qualifier value)\"",": ","'396131002'"," from " ]
                  }, {
                     "r" : "63",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every forty eight hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "63",
               "locator" : "74:68-74:90",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "66",
            "locator" : "75:1-75:130",
            "name" : "Every forty hours (qualifier value)",
            "id" : "396130001",
            "display" : "Every forty hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "66",
                  "s" : [ {
                     "value" : [ "","code ","\"Every forty hours (qualifier value)\"",": ","'396130001'"," from " ]
                  }, {
                     "r" : "65",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every forty hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "65",
               "locator" : "75:62-75:84",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "68",
            "locator" : "76:1-76:128",
            "name" : "Every four hours (qualifier value)",
            "id" : "225756002",
            "display" : "Every four hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "68",
                  "s" : [ {
                     "value" : [ "","code ","\"Every four hours (qualifier value)\"",": ","'225756002'"," from " ]
                  }, {
                     "r" : "67",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every four hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "67",
               "locator" : "76:61-76:83",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "70",
            "locator" : "77:1-77:142",
            "name" : "Every seventy two hours (qualifier value)",
            "id" : "396143001",
            "display" : "Every seventy two hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "70",
                  "s" : [ {
                     "value" : [ "","code ","\"Every seventy two hours (qualifier value)\"",": ","'396143001'"," from " ]
                  }, {
                     "r" : "69",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every seventy two hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "69",
               "locator" : "77:68-77:90",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "72",
            "locator" : "78:1-78:126",
            "name" : "Every six hours (qualifier value)",
            "id" : "307468000",
            "display" : "Every six hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "72",
                  "s" : [ {
                     "value" : [ "","code ","\"Every six hours (qualifier value)\"",": ","'307468000'"," from " ]
                  }, {
                     "r" : "71",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every six hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "71",
               "locator" : "78:60-78:82",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "74",
            "locator" : "79:1-79:144",
            "name" : "Every six to eight hours (qualifier value)",
            "id" : "396139000",
            "display" : "Every six to eight hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "74",
                  "s" : [ {
                     "value" : [ "","code ","\"Every six to eight hours (qualifier value)\"",": ","'396139000'"," from " ]
                  }, {
                     "r" : "73",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every six to eight hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "73",
               "locator" : "79:69-79:91",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "76",
            "locator" : "80:1-80:140",
            "name" : "Every thirty six hours (qualifier value)",
            "id" : "396126004",
            "display" : "Every thirty six hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "76",
                  "s" : [ {
                     "value" : [ "","code ","\"Every thirty six hours (qualifier value)\"",": ","'396126004'"," from " ]
                  }, {
                     "r" : "75",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every thirty six hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "75",
               "locator" : "80:67-80:89",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "78",
            "locator" : "81:1-81:146",
            "name" : "Every three to four hours (qualifier value)",
            "id" : "225754004",
            "display" : "Every three to four hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "78",
                  "s" : [ {
                     "value" : [ "","code ","\"Every three to four hours (qualifier value)\"",": ","'225754004'"," from " ]
                  }, {
                     "r" : "77",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every three to four hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "77",
               "locator" : "81:70-81:92",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "80",
            "locator" : "82:1-82:144",
            "name" : "Every three to six hours (qualifier value)",
            "id" : "396127008",
            "display" : "Every three to six hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "80",
                  "s" : [ {
                     "value" : [ "","code ","\"Every three to six hours (qualifier value)\"",": ","'396127008'"," from " ]
                  }, {
                     "r" : "79",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every three to six hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "79",
               "locator" : "82:69-82:91",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "82",
            "locator" : "83:1-83:132",
            "name" : "Every twelve hours (qualifier value)",
            "id" : "307470009",
            "display" : "Every twelve hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "82",
                  "s" : [ {
                     "value" : [ "","code ","\"Every twelve hours (qualifier value)\"",": ","'307470009'"," from " ]
                  }, {
                     "r" : "81",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every twelve hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "81",
               "locator" : "83:63-83:85",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "84",
            "locator" : "84:1-84:142",
            "name" : "Every twenty four hours (qualifier value)",
            "id" : "396125000",
            "display" : "Every twenty four hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "84",
                  "s" : [ {
                     "value" : [ "","code ","\"Every twenty four hours (qualifier value)\"",": ","'396125000'"," from " ]
                  }, {
                     "r" : "83",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every twenty four hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "83",
               "locator" : "84:68-84:90",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "86",
            "locator" : "85:1-85:142",
            "name" : "Every two to four hours (qualifier value)",
            "id" : "225752000",
            "display" : "Every two to four hours (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "86",
                  "s" : [ {
                     "value" : [ "","code ","\"Every two to four hours (qualifier value)\"",": ","'225752000'"," from " ]
                  }, {
                     "r" : "85",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Every two to four hours (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "85",
               "locator" : "85:68-85:90",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "88",
            "locator" : "86:1-86:128",
            "name" : "Four times daily (qualifier value)",
            "id" : "307439001",
            "display" : "Four times daily (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "88",
                  "s" : [ {
                     "value" : [ "","code ","\"Four times daily (qualifier value)\"",": ","'307439001'"," from " ]
                  }, {
                     "r" : "87",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Four times daily (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "87",
               "locator" : "86:61-86:83",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "90",
            "locator" : "87:1-87:116",
            "name" : "Once daily (qualifier value)",
            "id" : "229797004",
            "display" : "Once daily (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "90",
                  "s" : [ {
                     "value" : [ "","code ","\"Once daily (qualifier value)\"",": ","'229797004'"," from " ]
                  }, {
                     "r" : "89",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Once daily (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "89",
               "locator" : "87:55-87:77",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "92",
            "locator" : "88:1-88:142",
            "name" : "One to four times a day (qualifier value)",
            "id" : "396109005",
            "display" : "One to four times a day (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "92",
                  "s" : [ {
                     "value" : [ "","code ","\"One to four times a day (qualifier value)\"",": ","'396109005'"," from " ]
                  }, {
                     "r" : "91",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'One to four times a day (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "91",
               "locator" : "88:68-88:90",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "94",
            "locator" : "89:1-89:144",
            "name" : "One to three times a day (qualifier value)",
            "id" : "396108002",
            "display" : "One to three times a day (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "94",
                  "s" : [ {
                     "value" : [ "","code ","\"One to three times a day (qualifier value)\"",": ","'396108002'"," from " ]
                  }, {
                     "r" : "93",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'One to three times a day (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "93",
               "locator" : "89:69-89:91",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "96",
            "locator" : "90:1-90:140",
            "name" : "One to two times a day (qualifier value)",
            "id" : "396107007",
            "display" : "One to two times a day (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "96",
                  "s" : [ {
                     "value" : [ "","code ","\"One to two times a day (qualifier value)\"",": ","'396107007'"," from " ]
                  }, {
                     "r" : "95",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'One to two times a day (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "95",
               "locator" : "90:67-90:89",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "98",
            "locator" : "91:1-91:130",
            "name" : "Three times daily (qualifier value)",
            "id" : "229798009",
            "display" : "Three times daily (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "98",
                  "s" : [ {
                     "value" : [ "","code ","\"Three times daily (qualifier value)\"",": ","'229798009'"," from " ]
                  }, {
                     "r" : "97",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Three times daily (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "97",
               "locator" : "91:62-91:84",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "100",
            "locator" : "92:1-92:118",
            "name" : "Twice a day (qualifier value)",
            "id" : "229799001",
            "display" : "Twice a day (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "100",
                  "s" : [ {
                     "value" : [ "","code ","\"Twice a day (qualifier value)\"",": ","'229799001'"," from " ]
                  }, {
                     "r" : "99",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Twice a day (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "99",
               "locator" : "92:56-92:78",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         }, {
            "localId" : "102",
            "locator" : "93:1-93:142",
            "name" : "Two to four times a day (qualifier value)",
            "id" : "396111001",
            "display" : "Two to four times a day (qualifier value)",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "102",
                  "s" : [ {
                     "value" : [ "","code ","\"Two to four times a day (qualifier value)\"",": ","'396111001'"," from " ]
                  }, {
                     "r" : "101",
                     "s" : [ {
                        "value" : [ "USCoreCommon",".","\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Two to four times a day (qualifier value)'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "101",
               "locator" : "93:68-93:90",
               "name" : "SNOMEDCT",
               "libraryName" : "USCoreCommon"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "locator" : "97:1-97:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "97:1-97:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "97:1-97:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "348",
            "locator" : "118:1-142:5",
            "name" : "ToDaily",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "348",
                  "s" : [ {
                     "value" : [ "/*\n Goal is to get to number of days\n Two broad approaches to the calculation:\n  1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered\n  2) Based on relevant period, determine a covered interval and calculate the length of that interval in days\n\nThis topic covers several use cases and illustrates how to calculate Cumulative\nMedication Duration for each type of medication resource using the supply and\nfrequency approach.\n*/\n\n/*\n  For the first approach, we need to get from frequency to a frequency/day\n  So we define ToDaily\n*/\n\n/*\n  Calculates daily frequency given frequency within a period\n*/\n","define function ","ToDaily","(","frequency"," " ]
                  }, {
                     "r" : "106",
                     "s" : [ {
                        "value" : [ "System",".","Integer" ]
                     } ]
                  }, {
                     "value" : [ ", ","period"," " ]
                  }, {
                     "r" : "107",
                     "s" : [ {
                        "value" : [ "System",".","Quantity" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "347",
                     "s" : [ {
                        "r" : "347",
                        "s" : [ {
                           "value" : [ "case " ]
                        }, {
                           "r" : "109",
                           "s" : [ {
                              "r" : "108",
                              "s" : [ {
                                 "value" : [ "period" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "109",
                              "s" : [ {
                                 "value" : [ "unit" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "117",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "110",
                              "s" : [ {
                                 "value" : [ "'h'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "116",
                              "s" : [ {
                                 "r" : "111",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " * " ]
                              }, {
                                 "r" : "115",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "115",
                                    "s" : [ {
                                       "r" : "112",
                                       "value" : [ "24.0"," / " ]
                                    }, {
                                       "r" : "114",
                                       "s" : [ {
                                          "r" : "113",
                                          "s" : [ {
                                             "value" : [ "period" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "114",
                                          "s" : [ {
                                             "value" : [ "value" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "127",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "118",
                              "s" : [ {
                                 "value" : [ "'min'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "126",
                              "s" : [ {
                                 "r" : "124",
                                 "s" : [ {
                                    "r" : "119",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "123",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "123",
                                       "s" : [ {
                                          "r" : "120",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "122",
                                          "s" : [ {
                                             "r" : "121",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "122",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "125",
                                 "value" : [ " * ","60" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "139",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "128",
                              "s" : [ {
                                 "value" : [ "'s'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "138",
                              "s" : [ {
                                 "r" : "136",
                                 "s" : [ {
                                    "r" : "134",
                                    "s" : [ {
                                       "r" : "129",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    }, {
                                       "value" : [ " * " ]
                                    }, {
                                       "r" : "133",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "133",
                                          "s" : [ {
                                             "r" : "130",
                                             "value" : [ "24.0"," / " ]
                                          }, {
                                             "r" : "132",
                                             "s" : [ {
                                                "r" : "131",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "132",
                                                "s" : [ {
                                                   "value" : [ "value" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "135",
                                    "value" : [ " * ","60" ]
                                 } ]
                              }, {
                                 "r" : "137",
                                 "value" : [ " * ","60" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "149",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "140",
                              "s" : [ {
                                 "value" : [ "'d'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "148",
                              "s" : [ {
                                 "r" : "146",
                                 "s" : [ {
                                    "r" : "141",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "145",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "145",
                                       "s" : [ {
                                          "r" : "142",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "144",
                                          "s" : [ {
                                             "r" : "143",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "144",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "147",
                                 "value" : [ " / ","24" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "161",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "150",
                              "s" : [ {
                                 "value" : [ "'wk'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "160",
                              "s" : [ {
                                 "r" : "156",
                                 "s" : [ {
                                    "r" : "151",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "155",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "155",
                                       "s" : [ {
                                          "r" : "152",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "154",
                                          "s" : [ {
                                             "r" : "153",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "154",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "159",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "159",
                                    "s" : [ {
                                       "r" : "157",
                                       "value" : [ "24"," * ","7" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "173",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "162",
                              "s" : [ {
                                 "value" : [ "'mo'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "172",
                              "s" : [ {
                                 "r" : "168",
                                 "s" : [ {
                                    "r" : "163",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "167",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "167",
                                       "s" : [ {
                                          "r" : "164",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "166",
                                          "s" : [ {
                                             "r" : "165",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "166",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "171",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "171",
                                    "s" : [ {
                                       "r" : "169",
                                       "value" : [ "24"," * ","30" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " /* assuming 30 days in month */\n    " ]
                        }, {
                           "r" : "185",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "174",
                              "s" : [ {
                                 "value" : [ "'a'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "184",
                              "s" : [ {
                                 "r" : "180",
                                 "s" : [ {
                                    "r" : "175",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "179",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "179",
                                       "s" : [ {
                                          "r" : "176",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "178",
                                          "s" : [ {
                                             "r" : "177",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "178",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "183",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "183",
                                    "s" : [ {
                                       "r" : "181",
                                       "value" : [ "24"," * ","365" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " /* assuming 365 days in year */\n    " ]
                        }, {
                           "r" : "193",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "186",
                              "s" : [ {
                                 "value" : [ "'hour'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "192",
                              "s" : [ {
                                 "r" : "187",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " * " ]
                              }, {
                                 "r" : "191",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "191",
                                    "s" : [ {
                                       "r" : "188",
                                       "value" : [ "24.0"," / " ]
                                    }, {
                                       "r" : "190",
                                       "s" : [ {
                                          "r" : "189",
                                          "s" : [ {
                                             "value" : [ "period" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "190",
                                          "s" : [ {
                                             "value" : [ "value" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "203",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "194",
                              "s" : [ {
                                 "value" : [ "'minute'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "202",
                              "s" : [ {
                                 "r" : "200",
                                 "s" : [ {
                                    "r" : "195",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "199",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "199",
                                       "s" : [ {
                                          "r" : "196",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "198",
                                          "s" : [ {
                                             "r" : "197",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "198",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "201",
                                 "value" : [ " * ","60" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "215",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "204",
                              "s" : [ {
                                 "value" : [ "'second'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "214",
                              "s" : [ {
                                 "r" : "212",
                                 "s" : [ {
                                    "r" : "210",
                                    "s" : [ {
                                       "r" : "205",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    }, {
                                       "value" : [ " * " ]
                                    }, {
                                       "r" : "209",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "209",
                                          "s" : [ {
                                             "r" : "206",
                                             "value" : [ "24.0"," / " ]
                                          }, {
                                             "r" : "208",
                                             "s" : [ {
                                                "r" : "207",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "208",
                                                "s" : [ {
                                                   "value" : [ "value" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "211",
                                    "value" : [ " * ","60" ]
                                 } ]
                              }, {
                                 "r" : "213",
                                 "value" : [ " * ","60" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "225",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "216",
                              "s" : [ {
                                 "value" : [ "'day'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "224",
                              "s" : [ {
                                 "r" : "222",
                                 "s" : [ {
                                    "r" : "217",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "221",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "221",
                                       "s" : [ {
                                          "r" : "218",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "220",
                                          "s" : [ {
                                             "r" : "219",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "220",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "223",
                                 "value" : [ " / ","24" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "237",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "226",
                              "s" : [ {
                                 "value" : [ "'week'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "236",
                              "s" : [ {
                                 "r" : "232",
                                 "s" : [ {
                                    "r" : "227",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "231",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "231",
                                       "s" : [ {
                                          "r" : "228",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "230",
                                          "s" : [ {
                                             "r" : "229",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "230",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "235",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "235",
                                    "s" : [ {
                                       "r" : "233",
                                       "value" : [ "24"," * ","7" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "249",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "238",
                              "s" : [ {
                                 "value" : [ "'month'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "248",
                              "s" : [ {
                                 "r" : "244",
                                 "s" : [ {
                                    "r" : "239",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "243",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "243",
                                       "s" : [ {
                                          "r" : "240",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "242",
                                          "s" : [ {
                                             "r" : "241",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "242",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "247",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "247",
                                    "s" : [ {
                                       "r" : "245",
                                       "value" : [ "24"," * ","30" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " /* assuming 30 days in month */\n    " ]
                        }, {
                           "r" : "261",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "250",
                              "s" : [ {
                                 "value" : [ "'year'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "260",
                              "s" : [ {
                                 "r" : "256",
                                 "s" : [ {
                                    "r" : "251",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "255",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "255",
                                       "s" : [ {
                                          "r" : "252",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "254",
                                          "s" : [ {
                                             "r" : "253",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "254",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "259",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "259",
                                    "s" : [ {
                                       "r" : "257",
                                       "value" : [ "24"," * ","365" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " /* assuming 365 days in year */\n    " ]
                        }, {
                           "r" : "269",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "262",
                              "s" : [ {
                                 "value" : [ "'hours'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "268",
                              "s" : [ {
                                 "r" : "263",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " * " ]
                              }, {
                                 "r" : "267",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "267",
                                    "s" : [ {
                                       "r" : "264",
                                       "value" : [ "24.0"," / " ]
                                    }, {
                                       "r" : "266",
                                       "s" : [ {
                                          "r" : "265",
                                          "s" : [ {
                                             "value" : [ "period" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "266",
                                          "s" : [ {
                                             "value" : [ "value" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "279",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "270",
                              "s" : [ {
                                 "value" : [ "'minutes'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "278",
                              "s" : [ {
                                 "r" : "276",
                                 "s" : [ {
                                    "r" : "271",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "275",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "275",
                                       "s" : [ {
                                          "r" : "272",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "274",
                                          "s" : [ {
                                             "r" : "273",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "274",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "277",
                                 "value" : [ " * ","60" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "291",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "280",
                              "s" : [ {
                                 "value" : [ "'seconds'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "290",
                              "s" : [ {
                                 "r" : "288",
                                 "s" : [ {
                                    "r" : "286",
                                    "s" : [ {
                                       "r" : "281",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    }, {
                                       "value" : [ " * " ]
                                    }, {
                                       "r" : "285",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "285",
                                          "s" : [ {
                                             "r" : "282",
                                             "value" : [ "24.0"," / " ]
                                          }, {
                                             "r" : "284",
                                             "s" : [ {
                                                "r" : "283",
                                                "s" : [ {
                                                   "value" : [ "period" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "284",
                                                "s" : [ {
                                                   "value" : [ "value" ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "287",
                                    "value" : [ " * ","60" ]
                                 } ]
                              }, {
                                 "r" : "289",
                                 "value" : [ " * ","60" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "301",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "292",
                              "s" : [ {
                                 "value" : [ "'days'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "300",
                              "s" : [ {
                                 "r" : "298",
                                 "s" : [ {
                                    "r" : "293",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "297",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "297",
                                       "s" : [ {
                                          "r" : "294",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "296",
                                          "s" : [ {
                                             "r" : "295",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "296",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "299",
                                 "value" : [ " / ","24" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "313",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "302",
                              "s" : [ {
                                 "value" : [ "'weeks'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "312",
                              "s" : [ {
                                 "r" : "308",
                                 "s" : [ {
                                    "r" : "303",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "307",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "307",
                                       "s" : [ {
                                          "r" : "304",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "306",
                                          "s" : [ {
                                             "r" : "305",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "306",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "311",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "311",
                                    "s" : [ {
                                       "r" : "309",
                                       "value" : [ "24"," * ","7" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "325",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "314",
                              "s" : [ {
                                 "value" : [ "'months'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "324",
                              "s" : [ {
                                 "r" : "320",
                                 "s" : [ {
                                    "r" : "315",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "319",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "319",
                                       "s" : [ {
                                          "r" : "316",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "318",
                                          "s" : [ {
                                             "r" : "317",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "318",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "323",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "323",
                                    "s" : [ {
                                       "r" : "321",
                                       "value" : [ "24"," * ","30" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " /* assuming 30 days in month */\n    " ]
                        }, {
                           "r" : "337",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "326",
                              "s" : [ {
                                 "value" : [ "'years'" ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "336",
                              "s" : [ {
                                 "r" : "332",
                                 "s" : [ {
                                    "r" : "327",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "331",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "331",
                                       "s" : [ {
                                          "r" : "328",
                                          "value" : [ "24.0"," / " ]
                                       }, {
                                          "r" : "330",
                                          "s" : [ {
                                             "r" : "329",
                                             "s" : [ {
                                                "value" : [ "period" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "330",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " / " ]
                              }, {
                                 "r" : "335",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "335",
                                    "s" : [ {
                                       "r" : "333",
                                       "value" : [ "24"," * ","365" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " /* assuming 365 days in year */\n    else " ]
                        }, {
                           "r" : "346",
                           "s" : [ {
                              "r" : "338",
                              "value" : [ "Message","(","null",", ","true",", " ]
                           }, {
                              "r" : "340",
                              "s" : [ {
                                 "value" : [ "'CMDLogic.ToDaily.UnknownUnit'" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "341",
                              "s" : [ {
                                 "value" : [ "ErrorLevel" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "345",
                              "s" : [ {
                                 "r" : "342",
                                 "s" : [ {
                                    "value" : [ "'Unknown unit '" ]
                                 } ]
                              }, {
                                 "value" : [ " & " ]
                              }, {
                                 "r" : "344",
                                 "s" : [ {
                                    "r" : "343",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "344",
                                    "s" : [ {
                                       "value" : [ "unit" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ "\n  end" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "347",
               "locator" : "119:3-142:5",
               "type" : "Case",
               "comparand" : {
                  "localId" : "109",
                  "locator" : "119:8-119:18",
                  "path" : "unit",
                  "type" : "Property",
                  "source" : {
                     "localId" : "108",
                     "locator" : "119:8-119:13",
                     "name" : "period",
                     "type" : "OperandRef"
                  }
               },
               "caseItem" : [ {
                  "localId" : "117",
                  "locator" : "120:5-120:51",
                  "when" : {
                     "localId" : "110",
                     "locator" : "120:10-120:12",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "h",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "116",
                     "locator" : "120:19-120:51",
                     "type" : "Multiply",
                     "operand" : [ {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "111",
                           "locator" : "120:19-120:27",
                           "name" : "frequency",
                           "type" : "OperandRef"
                        }
                     }, {
                        "localId" : "115",
                        "locator" : "120:31-120:51",
                        "type" : "Divide",
                        "operand" : [ {
                           "localId" : "112",
                           "locator" : "120:32-120:35",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                           "value" : "24.0",
                           "type" : "Literal"
                        }, {
                           "localId" : "114",
                           "locator" : "120:39-120:50",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "113",
                              "locator" : "120:39-120:44",
                              "name" : "period",
                              "type" : "OperandRef"
                           }
                        } ]
                     } ]
                  }
               }, {
                  "localId" : "127",
                  "locator" : "121:5-121:58",
                  "when" : {
                     "localId" : "118",
                     "locator" : "121:10-121:14",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "min",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "126",
                     "locator" : "121:21-121:58",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "124",
                        "locator" : "121:21-121:53",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "119",
                              "locator" : "121:21-121:29",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "123",
                           "locator" : "121:33-121:53",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "120",
                              "locator" : "121:34-121:37",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "122",
                              "locator" : "121:41-121:52",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "121",
                                 "locator" : "121:41-121:46",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "125",
                           "locator" : "121:57-121:58",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "60",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "139",
                  "locator" : "122:5-122:61",
                  "when" : {
                     "localId" : "128",
                     "locator" : "122:10-122:12",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "s",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "138",
                     "locator" : "122:19-122:61",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "136",
                        "locator" : "122:19-122:56",
                        "type" : "Multiply",
                        "operand" : [ {
                           "localId" : "134",
                           "locator" : "122:19-122:51",
                           "type" : "Multiply",
                           "operand" : [ {
                              "type" : "ToDecimal",
                              "operand" : {
                                 "localId" : "129",
                                 "locator" : "122:19-122:27",
                                 "name" : "frequency",
                                 "type" : "OperandRef"
                              }
                           }, {
                              "localId" : "133",
                              "locator" : "122:31-122:51",
                              "type" : "Divide",
                              "operand" : [ {
                                 "localId" : "130",
                                 "locator" : "122:32-122:35",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                                 "value" : "24.0",
                                 "type" : "Literal"
                              }, {
                                 "localId" : "132",
                                 "locator" : "122:39-122:50",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "131",
                                    "locator" : "122:39-122:44",
                                    "name" : "period",
                                    "type" : "OperandRef"
                                 }
                              } ]
                           } ]
                        }, {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "135",
                              "locator" : "122:55-122:56",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "60",
                              "type" : "Literal"
                           }
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "137",
                           "locator" : "122:60-122:61",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "60",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "149",
                  "locator" : "123:5-123:56",
                  "when" : {
                     "localId" : "140",
                     "locator" : "123:10-123:12",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "d",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "148",
                     "locator" : "123:19-123:56",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "146",
                        "locator" : "123:19-123:51",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "141",
                              "locator" : "123:19-123:27",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "145",
                           "locator" : "123:31-123:51",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "142",
                              "locator" : "123:32-123:35",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "144",
                              "locator" : "123:39-123:50",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "143",
                                 "locator" : "123:39-123:44",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "147",
                           "locator" : "123:55-123:56",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "24",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "161",
                  "locator" : "124:5-124:63",
                  "when" : {
                     "localId" : "150",
                     "locator" : "124:10-124:13",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "wk",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "160",
                     "locator" : "124:20-124:63",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "156",
                        "locator" : "124:20-124:52",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "151",
                              "locator" : "124:20-124:28",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "155",
                           "locator" : "124:32-124:52",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "152",
                              "locator" : "124:33-124:36",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "154",
                              "locator" : "124:40-124:51",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "153",
                                 "locator" : "124:40-124:45",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "159",
                           "locator" : "124:56-124:63",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "157",
                              "locator" : "124:57-124:58",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "158",
                              "locator" : "124:62",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "7",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "173",
                  "locator" : "125:5-125:64",
                  "when" : {
                     "localId" : "162",
                     "locator" : "125:10-125:13",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "mo",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "172",
                     "locator" : "125:20-125:64",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "168",
                        "locator" : "125:20-125:52",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "163",
                              "locator" : "125:20-125:28",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "167",
                           "locator" : "125:32-125:52",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "164",
                              "locator" : "125:33-125:36",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "166",
                              "locator" : "125:40-125:51",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "165",
                                 "locator" : "125:40-125:45",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "171",
                           "locator" : "125:56-125:64",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "169",
                              "locator" : "125:57-125:58",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "170",
                              "locator" : "125:62-125:63",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "30",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "185",
                  "locator" : "126:5-126:64",
                  "when" : {
                     "localId" : "174",
                     "locator" : "126:10-126:12",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "a",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "184",
                     "locator" : "126:19-126:64",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "180",
                        "locator" : "126:19-126:51",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "175",
                              "locator" : "126:19-126:27",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "179",
                           "locator" : "126:31-126:51",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "176",
                              "locator" : "126:32-126:35",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "178",
                              "locator" : "126:39-126:50",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "177",
                                 "locator" : "126:39-126:44",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "183",
                           "locator" : "126:55-126:64",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "181",
                              "locator" : "126:56-126:57",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "182",
                              "locator" : "126:61-126:63",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "365",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "193",
                  "locator" : "127:5-127:54",
                  "when" : {
                     "localId" : "186",
                     "locator" : "127:10-127:15",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "hour",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "192",
                     "locator" : "127:22-127:54",
                     "type" : "Multiply",
                     "operand" : [ {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "187",
                           "locator" : "127:22-127:30",
                           "name" : "frequency",
                           "type" : "OperandRef"
                        }
                     }, {
                        "localId" : "191",
                        "locator" : "127:34-127:54",
                        "type" : "Divide",
                        "operand" : [ {
                           "localId" : "188",
                           "locator" : "127:35-127:38",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                           "value" : "24.0",
                           "type" : "Literal"
                        }, {
                           "localId" : "190",
                           "locator" : "127:42-127:53",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "189",
                              "locator" : "127:42-127:47",
                              "name" : "period",
                              "type" : "OperandRef"
                           }
                        } ]
                     } ]
                  }
               }, {
                  "localId" : "203",
                  "locator" : "128:5-128:61",
                  "when" : {
                     "localId" : "194",
                     "locator" : "128:10-128:17",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "minute",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "202",
                     "locator" : "128:24-128:61",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "200",
                        "locator" : "128:24-128:56",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "195",
                              "locator" : "128:24-128:32",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "199",
                           "locator" : "128:36-128:56",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "196",
                              "locator" : "128:37-128:40",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "198",
                              "locator" : "128:44-128:55",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "197",
                                 "locator" : "128:44-128:49",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "201",
                           "locator" : "128:60-128:61",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "60",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "215",
                  "locator" : "129:5-129:66",
                  "when" : {
                     "localId" : "204",
                     "locator" : "129:10-129:17",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "second",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "214",
                     "locator" : "129:24-129:66",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "212",
                        "locator" : "129:24-129:61",
                        "type" : "Multiply",
                        "operand" : [ {
                           "localId" : "210",
                           "locator" : "129:24-129:56",
                           "type" : "Multiply",
                           "operand" : [ {
                              "type" : "ToDecimal",
                              "operand" : {
                                 "localId" : "205",
                                 "locator" : "129:24-129:32",
                                 "name" : "frequency",
                                 "type" : "OperandRef"
                              }
                           }, {
                              "localId" : "209",
                              "locator" : "129:36-129:56",
                              "type" : "Divide",
                              "operand" : [ {
                                 "localId" : "206",
                                 "locator" : "129:37-129:40",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                                 "value" : "24.0",
                                 "type" : "Literal"
                              }, {
                                 "localId" : "208",
                                 "locator" : "129:44-129:55",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "207",
                                    "locator" : "129:44-129:49",
                                    "name" : "period",
                                    "type" : "OperandRef"
                                 }
                              } ]
                           } ]
                        }, {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "211",
                              "locator" : "129:60-129:61",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "60",
                              "type" : "Literal"
                           }
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "213",
                           "locator" : "129:65-129:66",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "60",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "225",
                  "locator" : "130:5-130:58",
                  "when" : {
                     "localId" : "216",
                     "locator" : "130:10-130:14",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "day",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "224",
                     "locator" : "130:21-130:58",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "222",
                        "locator" : "130:21-130:53",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "217",
                              "locator" : "130:21-130:29",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "221",
                           "locator" : "130:33-130:53",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "218",
                              "locator" : "130:34-130:37",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "220",
                              "locator" : "130:41-130:52",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "219",
                                 "locator" : "130:41-130:46",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "223",
                           "locator" : "130:57-130:58",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "24",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "237",
                  "locator" : "131:5-131:65",
                  "when" : {
                     "localId" : "226",
                     "locator" : "131:10-131:15",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "week",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "236",
                     "locator" : "131:22-131:65",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "232",
                        "locator" : "131:22-131:54",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "227",
                              "locator" : "131:22-131:30",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "231",
                           "locator" : "131:34-131:54",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "228",
                              "locator" : "131:35-131:38",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "230",
                              "locator" : "131:42-131:53",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "229",
                                 "locator" : "131:42-131:47",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "235",
                           "locator" : "131:58-131:65",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "233",
                              "locator" : "131:59-131:60",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "234",
                              "locator" : "131:64",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "7",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "249",
                  "locator" : "132:5-132:67",
                  "when" : {
                     "localId" : "238",
                     "locator" : "132:10-132:16",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "month",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "248",
                     "locator" : "132:23-132:67",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "244",
                        "locator" : "132:23-132:55",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "239",
                              "locator" : "132:23-132:31",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "243",
                           "locator" : "132:35-132:55",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "240",
                              "locator" : "132:36-132:39",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "242",
                              "locator" : "132:43-132:54",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "241",
                                 "locator" : "132:43-132:48",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "247",
                           "locator" : "132:59-132:67",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "245",
                              "locator" : "132:60-132:61",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "246",
                              "locator" : "132:65-132:66",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "30",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "261",
                  "locator" : "133:5-133:67",
                  "when" : {
                     "localId" : "250",
                     "locator" : "133:10-133:15",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "year",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "260",
                     "locator" : "133:22-133:67",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "256",
                        "locator" : "133:22-133:54",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "251",
                              "locator" : "133:22-133:30",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "255",
                           "locator" : "133:34-133:54",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "252",
                              "locator" : "133:35-133:38",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "254",
                              "locator" : "133:42-133:53",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "253",
                                 "locator" : "133:42-133:47",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "259",
                           "locator" : "133:58-133:67",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "257",
                              "locator" : "133:59-133:60",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "258",
                              "locator" : "133:64-133:66",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "365",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "269",
                  "locator" : "134:5-134:55",
                  "when" : {
                     "localId" : "262",
                     "locator" : "134:10-134:16",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "hours",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "268",
                     "locator" : "134:23-134:55",
                     "type" : "Multiply",
                     "operand" : [ {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "263",
                           "locator" : "134:23-134:31",
                           "name" : "frequency",
                           "type" : "OperandRef"
                        }
                     }, {
                        "localId" : "267",
                        "locator" : "134:35-134:55",
                        "type" : "Divide",
                        "operand" : [ {
                           "localId" : "264",
                           "locator" : "134:36-134:39",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                           "value" : "24.0",
                           "type" : "Literal"
                        }, {
                           "localId" : "266",
                           "locator" : "134:43-134:54",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "265",
                              "locator" : "134:43-134:48",
                              "name" : "period",
                              "type" : "OperandRef"
                           }
                        } ]
                     } ]
                  }
               }, {
                  "localId" : "279",
                  "locator" : "135:5-135:62",
                  "when" : {
                     "localId" : "270",
                     "locator" : "135:10-135:18",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "minutes",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "278",
                     "locator" : "135:25-135:62",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "276",
                        "locator" : "135:25-135:57",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "271",
                              "locator" : "135:25-135:33",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "275",
                           "locator" : "135:37-135:57",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "272",
                              "locator" : "135:38-135:41",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "274",
                              "locator" : "135:45-135:56",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "273",
                                 "locator" : "135:45-135:50",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "277",
                           "locator" : "135:61-135:62",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "60",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "291",
                  "locator" : "136:5-136:67",
                  "when" : {
                     "localId" : "280",
                     "locator" : "136:10-136:18",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "seconds",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "290",
                     "locator" : "136:25-136:67",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "288",
                        "locator" : "136:25-136:62",
                        "type" : "Multiply",
                        "operand" : [ {
                           "localId" : "286",
                           "locator" : "136:25-136:57",
                           "type" : "Multiply",
                           "operand" : [ {
                              "type" : "ToDecimal",
                              "operand" : {
                                 "localId" : "281",
                                 "locator" : "136:25-136:33",
                                 "name" : "frequency",
                                 "type" : "OperandRef"
                              }
                           }, {
                              "localId" : "285",
                              "locator" : "136:37-136:57",
                              "type" : "Divide",
                              "operand" : [ {
                                 "localId" : "282",
                                 "locator" : "136:38-136:41",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                                 "value" : "24.0",
                                 "type" : "Literal"
                              }, {
                                 "localId" : "284",
                                 "locator" : "136:45-136:56",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "283",
                                    "locator" : "136:45-136:50",
                                    "name" : "period",
                                    "type" : "OperandRef"
                                 }
                              } ]
                           } ]
                        }, {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "287",
                              "locator" : "136:61-136:62",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "60",
                              "type" : "Literal"
                           }
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "289",
                           "locator" : "136:66-136:67",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "60",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "301",
                  "locator" : "137:5-137:59",
                  "when" : {
                     "localId" : "292",
                     "locator" : "137:10-137:15",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "days",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "300",
                     "locator" : "137:22-137:59",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "298",
                        "locator" : "137:22-137:54",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "293",
                              "locator" : "137:22-137:30",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "297",
                           "locator" : "137:34-137:54",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "294",
                              "locator" : "137:35-137:38",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "296",
                              "locator" : "137:42-137:53",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "295",
                                 "locator" : "137:42-137:47",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "299",
                           "locator" : "137:58-137:59",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                           "value" : "24",
                           "type" : "Literal"
                        }
                     } ]
                  }
               }, {
                  "localId" : "313",
                  "locator" : "138:5-138:66",
                  "when" : {
                     "localId" : "302",
                     "locator" : "138:10-138:16",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "weeks",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "312",
                     "locator" : "138:23-138:66",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "308",
                        "locator" : "138:23-138:55",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "303",
                              "locator" : "138:23-138:31",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "307",
                           "locator" : "138:35-138:55",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "304",
                              "locator" : "138:36-138:39",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "306",
                              "locator" : "138:43-138:54",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "305",
                                 "locator" : "138:43-138:48",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "311",
                           "locator" : "138:59-138:66",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "309",
                              "locator" : "138:60-138:61",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "310",
                              "locator" : "138:65",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "7",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "325",
                  "locator" : "139:5-139:68",
                  "when" : {
                     "localId" : "314",
                     "locator" : "139:10-139:17",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "months",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "324",
                     "locator" : "139:24-139:68",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "320",
                        "locator" : "139:24-139:56",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "315",
                              "locator" : "139:24-139:32",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "319",
                           "locator" : "139:36-139:56",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "316",
                              "locator" : "139:37-139:40",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "318",
                              "locator" : "139:44-139:55",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "317",
                                 "locator" : "139:44-139:49",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "323",
                           "locator" : "139:60-139:68",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "321",
                              "locator" : "139:61-139:62",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "322",
                              "locator" : "139:66-139:67",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "30",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "337",
                  "locator" : "140:5-140:68",
                  "when" : {
                     "localId" : "326",
                     "locator" : "140:10-140:16",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "years",
                     "type" : "Literal"
                  },
                  "then" : {
                     "localId" : "336",
                     "locator" : "140:23-140:68",
                     "type" : "Divide",
                     "operand" : [ {
                        "localId" : "332",
                        "locator" : "140:23-140:55",
                        "type" : "Multiply",
                        "operand" : [ {
                           "type" : "ToDecimal",
                           "operand" : {
                              "localId" : "327",
                              "locator" : "140:23-140:31",
                              "name" : "frequency",
                              "type" : "OperandRef"
                           }
                        }, {
                           "localId" : "331",
                           "locator" : "140:35-140:55",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "328",
                              "locator" : "140:36-140:39",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                              "value" : "24.0",
                              "type" : "Literal"
                           }, {
                              "localId" : "330",
                              "locator" : "140:43-140:54",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "329",
                                 "locator" : "140:43-140:48",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "335",
                           "locator" : "140:59-140:68",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "333",
                              "locator" : "140:60-140:61",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "24",
                              "type" : "Literal"
                           }, {
                              "localId" : "334",
                              "locator" : "140:65-140:67",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "365",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               } ],
               "else" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Decimal",
                  "type" : "As",
                  "operand" : {
                     "localId" : "346",
                     "locator" : "141:10-141:103",
                     "type" : "Message",
                     "source" : {
                        "localId" : "338",
                        "locator" : "141:18-141:21",
                        "type" : "Null"
                     },
                     "condition" : {
                        "localId" : "339",
                        "locator" : "141:24-141:27",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "value" : "true",
                        "type" : "Literal"
                     },
                     "code" : {
                        "localId" : "340",
                        "locator" : "141:30-141:59",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "CMDLogic.ToDaily.UnknownUnit",
                        "type" : "Literal"
                     },
                     "severity" : {
                        "localId" : "341",
                        "locator" : "141:62-141:71",
                        "name" : "ErrorLevel",
                        "type" : "ParameterRef"
                     },
                     "message" : {
                        "localId" : "345",
                        "locator" : "141:74-141:102",
                        "type" : "Concatenate",
                        "operand" : [ {
                           "type" : "Coalesce",
                           "operand" : [ {
                              "localId" : "342",
                              "locator" : "141:74-141:88",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "Unknown unit ",
                              "type" : "Literal"
                           }, {
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "",
                              "type" : "Literal"
                           } ]
                        }, {
                           "type" : "Coalesce",
                           "operand" : [ {
                              "localId" : "344",
                              "locator" : "141:92-141:102",
                              "path" : "unit",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "343",
                                 "locator" : "141:92-141:97",
                                 "name" : "period",
                                 "type" : "OperandRef"
                              }
                           }, {
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "",
                              "type" : "Literal"
                           } ]
                        } ]
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "frequency",
               "operandTypeSpecifier" : {
                  "localId" : "106",
                  "locator" : "118:35-118:48",
                  "name" : "{urn:hl7-org:elm-types:r1}Integer",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "period",
               "operandTypeSpecifier" : {
                  "localId" : "107",
                  "locator" : "118:58-118:72",
                  "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "595",
            "locator" : "150:1-203:5",
            "name" : "ToDaily",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "595",
                  "s" : [ {
                     "value" : [ "/*\n  Returns a daily frequency for the given code representation of frequency.\n  The function expects codes from the [EventTiming](http://hl7.org/fhir/codesystem-event-timing.html) or\n  [V3TimingEvent](http://hl7.org/fhir/v3/TimingEvent/cs.html) code systems.\n  // TODO: Determine whether or not we should use timing.code at all....\n*/\n","define function ","ToDaily","(","frequency"," " ]
                  }, {
                     "r" : "349",
                     "s" : [ {
                        "value" : [ "Code" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "594",
                     "s" : [ {
                        "r" : "594",
                        "s" : [ {
                           "value" : [ "case\n    " ]
                        }, {
                           "r" : "354",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "352",
                              "s" : [ {
                                 "r" : "350",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "351",
                                 "s" : [ {
                                    "value" : [ "\"HS\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "353",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " // event occurs [offset] before the hour of sleep (or trying to)\n    " ]
                        }, {
                           "r" : "359",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "357",
                              "s" : [ {
                                 "r" : "355",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "356",
                                 "s" : [ {
                                    "value" : [ "\"WAKE\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "358",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " // event occurs [offset] after waking\n    " ]
                        }, {
                           "r" : "364",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "362",
                              "s" : [ {
                                 "r" : "360",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "361",
                                 "s" : [ {
                                    "value" : [ "\"C\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "363",
                              "value" : [ " then ","3" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs at a meal (from the Latin cibus)\n    " ]
                        }, {
                           "r" : "369",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "367",
                              "s" : [ {
                                 "r" : "365",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "366",
                                 "s" : [ {
                                    "value" : [ "\"CM\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "368",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs at breakfast (from the Latin cibus matutinus)\n    " ]
                        }, {
                           "r" : "374",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "372",
                              "s" : [ {
                                 "r" : "370",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "371",
                                 "s" : [ {
                                    "value" : [ "\"CD\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "373",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs at lunch (from the Latin cibus diurnus)\n    " ]
                        }, {
                           "r" : "379",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "377",
                              "s" : [ {
                                 "r" : "375",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "376",
                                 "s" : [ {
                                    "value" : [ "\"CV\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "378",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs at dinner (from the Latin ante cibus vespertinus)\n    " ]
                        }, {
                           "r" : "384",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "382",
                              "s" : [ {
                                 "r" : "380",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "381",
                                 "s" : [ {
                                    "value" : [ "\"AC\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "383",
                              "value" : [ " then ","3" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] before a meal (from the Latin ante cibus)\n    " ]
                        }, {
                           "r" : "389",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "387",
                              "s" : [ {
                                 "r" : "385",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "386",
                                 "s" : [ {
                                    "value" : [ "\"ACM\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "388",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] before breakfast (from the Latin ante cibus matutinus)\n    " ]
                        }, {
                           "r" : "394",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "392",
                              "s" : [ {
                                 "r" : "390",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "391",
                                 "s" : [ {
                                    "value" : [ "\"ACD\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "393",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] before lunch (from the Latin ante cibus diurnus)\n    " ]
                        }, {
                           "r" : "399",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "397",
                              "s" : [ {
                                 "r" : "395",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "396",
                                 "s" : [ {
                                    "value" : [ "\"ACV\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "398",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] before dinner (from the Latin ante cibus vespertinus)\n    " ]
                        }, {
                           "r" : "404",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "402",
                              "s" : [ {
                                 "r" : "400",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "401",
                                 "s" : [ {
                                    "value" : [ "\"PC\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "403",
                              "value" : [ " then ","3" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] after a meal (from the Latin post cibus)\n    " ]
                        }, {
                           "r" : "409",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "407",
                              "s" : [ {
                                 "r" : "405",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "406",
                                 "s" : [ {
                                    "value" : [ "\"PCM\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "408",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] after breakfast (from the Latin post cibus matutinus)\n    " ]
                        }, {
                           "r" : "414",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "412",
                              "s" : [ {
                                 "r" : "410",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "411",
                                 "s" : [ {
                                    "value" : [ "\"PCD\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "413",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] after lunch (from the Latin post cibus diurnus)\n    " ]
                        }, {
                           "r" : "419",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "417",
                              "s" : [ {
                                 "r" : "415",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "416",
                                 "s" : [ {
                                    "value" : [ "\"PCV\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "418",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tevent occurs [offset] after dinner (from the Latin post cibus vespertinus)\n\n    " ]
                        }, {
                           "r" : "424",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "422",
                              "s" : [ {
                                 "r" : "420",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "421",
                                 "s" : [ {
                                    "value" : [ "\"MORN\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "423",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tEvent occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "429",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "427",
                              "s" : [ {
                                 "r" : "425",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "426",
                                 "s" : [ {
                                    "value" : [ "\"MORN.early\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "428",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tEarly Morning\tEvent occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "434",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "432",
                              "s" : [ {
                                 "r" : "430",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "431",
                                 "s" : [ {
                                    "value" : [ "\"MORN.late\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "433",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " // Late Morning\tEvent occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "439",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "437",
                              "s" : [ {
                                 "r" : "435",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "436",
                                 "s" : [ {
                                    "value" : [ "\"NOON\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "438",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tNoon\tEvent occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "444",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "442",
                              "s" : [ {
                                 "r" : "440",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "441",
                                 "s" : [ {
                                    "value" : [ "\"AFT\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "443",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tAfternoon\tEvent occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "449",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "447",
                              "s" : [ {
                                 "r" : "445",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "446",
                                 "s" : [ {
                                    "value" : [ "\"AFT.early\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "448",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tEarly Afternoon\tEvent occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "454",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "452",
                              "s" : [ {
                                 "r" : "450",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "451",
                                 "s" : [ {
                                    "value" : [ "\"AFT.late\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "453",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tLate Afternoon\tEvent occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "459",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "457",
                              "s" : [ {
                                 "r" : "455",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "456",
                                 "s" : [ {
                                    "value" : [ "\"EVE\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "458",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tEvening\tEvent occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "464",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "462",
                              "s" : [ {
                                 "r" : "460",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "461",
                                 "s" : [ {
                                    "value" : [ "\"EVE.early\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "463",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tEarly Evening\tEvent occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "469",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "467",
                              "s" : [ {
                                 "r" : "465",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "466",
                                 "s" : [ {
                                    "value" : [ "\"EVE.late\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "468",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tLate Evening\tEvent occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "474",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "472",
                              "s" : [ {
                                 "r" : "470",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "471",
                                 "s" : [ {
                                    "value" : [ "\"NIGHT\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "473",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tNight\tEvent occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation.\n    " ]
                        }, {
                           "r" : "479",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "477",
                              "s" : [ {
                                 "r" : "475",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "476",
                                 "s" : [ {
                                    "value" : [ "\"PHS\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "478",
                              "value" : [ " then ","1" ]
                           } ]
                        }, {
                           "value" : [ " //\tAfter Sleep\tEvent occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation.\n\n    " ]
                        }, {
                           "r" : "484",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "482",
                              "s" : [ {
                                 "r" : "480",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "481",
                                 "s" : [ {
                                    "value" : [ "\"Once daily (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "483",
                              "value" : [ " then ","1.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "489",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "487",
                              "s" : [ {
                                 "r" : "485",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "486",
                                 "s" : [ {
                                    "value" : [ "\"Twice a day (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "488",
                              "value" : [ " then ","2.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "494",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "492",
                              "s" : [ {
                                 "r" : "490",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "491",
                                 "s" : [ {
                                    "value" : [ "\"Three times daily (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "493",
                              "value" : [ " then ","3.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "499",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "497",
                              "s" : [ {
                                 "r" : "495",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "496",
                                 "s" : [ {
                                    "value" : [ "\"Four times daily (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "498",
                              "value" : [ " then ","4.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "504",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "502",
                              "s" : [ {
                                 "r" : "500",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "501",
                                 "s" : [ {
                                    "value" : [ "\"Every twenty four hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "503",
                              "value" : [ " then ","1.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "509",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "507",
                              "s" : [ {
                                 "r" : "505",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "506",
                                 "s" : [ {
                                    "value" : [ "\"Every twelve hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "508",
                              "value" : [ " then ","2.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "514",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "512",
                              "s" : [ {
                                 "r" : "510",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "511",
                                 "s" : [ {
                                    "value" : [ "\"Every thirty six hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "513",
                              "value" : [ " then ","0.67" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "519",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "517",
                              "s" : [ {
                                 "r" : "515",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "516",
                                 "s" : [ {
                                    "value" : [ "\"Every eight hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "518",
                              "value" : [ " then ","3.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "524",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "522",
                              "s" : [ {
                                 "r" : "520",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "521",
                                 "s" : [ {
                                    "value" : [ "\"Every four hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "523",
                              "value" : [ " then ","6.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "529",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "527",
                              "s" : [ {
                                 "r" : "525",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "526",
                                 "s" : [ {
                                    "value" : [ "\"Every six hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "528",
                              "value" : [ " then ","4.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "534",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "532",
                              "s" : [ {
                                 "r" : "530",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "531",
                                 "s" : [ {
                                    "value" : [ "\"Every seventy two hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "533",
                              "value" : [ " then ","0.33" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "539",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "537",
                              "s" : [ {
                                 "r" : "535",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "536",
                                 "s" : [ {
                                    "value" : [ "\"Every forty eight hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "538",
                              "value" : [ " then ","0.5" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "544",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "542",
                              "s" : [ {
                                 "r" : "540",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "541",
                                 "s" : [ {
                                    "value" : [ "\"Every eight to twelve hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "543",
                              "value" : [ " then ","3.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "549",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "547",
                              "s" : [ {
                                 "r" : "545",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "546",
                                 "s" : [ {
                                    "value" : [ "\"Every six to eight hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "548",
                              "value" : [ " then ","4.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "554",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "552",
                              "s" : [ {
                                 "r" : "550",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "551",
                                 "s" : [ {
                                    "value" : [ "\"Every three to four hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "553",
                              "value" : [ " then ","8.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "559",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "557",
                              "s" : [ {
                                 "r" : "555",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "556",
                                 "s" : [ {
                                    "value" : [ "\"Every three to six hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "558",
                              "value" : [ " then ","8.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "564",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "562",
                              "s" : [ {
                                 "r" : "560",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "561",
                                 "s" : [ {
                                    "value" : [ "\"Every two to four hours (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "563",
                              "value" : [ " then ","12.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "569",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "567",
                              "s" : [ {
                                 "r" : "565",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "566",
                                 "s" : [ {
                                    "value" : [ "\"One to four times a day (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "568",
                              "value" : [ " then ","4.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "574",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "572",
                              "s" : [ {
                                 "r" : "570",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "571",
                                 "s" : [ {
                                    "value" : [ "\"One to three times a day (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "573",
                              "value" : [ " then ","3.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "579",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "577",
                              "s" : [ {
                                 "r" : "575",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "576",
                                 "s" : [ {
                                    "value" : [ "\"One to two times a day (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "578",
                              "value" : [ " then ","2.0" ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "584",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "582",
                              "s" : [ {
                                 "r" : "580",
                                 "s" : [ {
                                    "value" : [ "frequency" ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "581",
                                 "s" : [ {
                                    "value" : [ "\"Two to four times a day (qualifier value)\"" ]
                                 } ]
                              } ]
                           }, {
                              "r" : "583",
                              "value" : [ " then ","4.0" ]
                           } ]
                        }, {
                           "value" : [ "\n\n    else " ]
                        }, {
                           "r" : "593",
                           "s" : [ {
                              "r" : "585",
                              "value" : [ "Message","(","null",", ","true",", " ]
                           }, {
                              "r" : "587",
                              "s" : [ {
                                 "value" : [ "'CMDLogic.ToDaily.UnknownFrequencyCode'" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "588",
                              "s" : [ {
                                 "value" : [ "ErrorLevel" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "592",
                              "s" : [ {
                                 "r" : "589",
                                 "s" : [ {
                                    "value" : [ "'Unknown frequency code '" ]
                                 } ]
                              }, {
                                 "value" : [ " & " ]
                              }, {
                                 "r" : "591",
                                 "s" : [ {
                                    "r" : "590",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "591",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ "\n  end" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "594",
               "locator" : "151:3-203:5",
               "type" : "Case",
               "caseItem" : [ {
                  "localId" : "354",
                  "locator" : "152:5-152:32",
                  "when" : {
                     "localId" : "352",
                     "locator" : "152:10-152:25",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "350",
                        "locator" : "152:10-152:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "351",
                        "locator" : "152:22-152:25",
                        "name" : "HS",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "353",
                        "locator" : "152:32",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "359",
                  "locator" : "153:5-153:34",
                  "when" : {
                     "localId" : "357",
                     "locator" : "153:10-153:27",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "355",
                        "locator" : "153:10-153:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "356",
                        "locator" : "153:22-153:27",
                        "name" : "WAKE",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "358",
                        "locator" : "153:34",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "364",
                  "locator" : "154:5-154:31",
                  "when" : {
                     "localId" : "362",
                     "locator" : "154:10-154:24",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "360",
                        "locator" : "154:10-154:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "361",
                        "locator" : "154:22-154:24",
                        "name" : "C",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "363",
                        "locator" : "154:31",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "3",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "369",
                  "locator" : "155:5-155:32",
                  "when" : {
                     "localId" : "367",
                     "locator" : "155:10-155:25",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "365",
                        "locator" : "155:10-155:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "366",
                        "locator" : "155:22-155:25",
                        "name" : "CM",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "368",
                        "locator" : "155:32",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "374",
                  "locator" : "156:5-156:32",
                  "when" : {
                     "localId" : "372",
                     "locator" : "156:10-156:25",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "370",
                        "locator" : "156:10-156:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "371",
                        "locator" : "156:22-156:25",
                        "name" : "CD",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "373",
                        "locator" : "156:32",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "379",
                  "locator" : "157:5-157:32",
                  "when" : {
                     "localId" : "377",
                     "locator" : "157:10-157:25",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "375",
                        "locator" : "157:10-157:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "376",
                        "locator" : "157:22-157:25",
                        "name" : "CV",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "378",
                        "locator" : "157:32",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "384",
                  "locator" : "158:5-158:32",
                  "when" : {
                     "localId" : "382",
                     "locator" : "158:10-158:25",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "380",
                        "locator" : "158:10-158:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "381",
                        "locator" : "158:22-158:25",
                        "name" : "AC",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "383",
                        "locator" : "158:32",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "3",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "389",
                  "locator" : "159:5-159:33",
                  "when" : {
                     "localId" : "387",
                     "locator" : "159:10-159:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "385",
                        "locator" : "159:10-159:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "386",
                        "locator" : "159:22-159:26",
                        "name" : "ACM",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "388",
                        "locator" : "159:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "394",
                  "locator" : "160:5-160:33",
                  "when" : {
                     "localId" : "392",
                     "locator" : "160:10-160:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "390",
                        "locator" : "160:10-160:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "391",
                        "locator" : "160:22-160:26",
                        "name" : "ACD",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "393",
                        "locator" : "160:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "399",
                  "locator" : "161:5-161:33",
                  "when" : {
                     "localId" : "397",
                     "locator" : "161:10-161:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "395",
                        "locator" : "161:10-161:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "396",
                        "locator" : "161:22-161:26",
                        "name" : "ACV",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "398",
                        "locator" : "161:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "404",
                  "locator" : "162:5-162:32",
                  "when" : {
                     "localId" : "402",
                     "locator" : "162:10-162:25",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "400",
                        "locator" : "162:10-162:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "401",
                        "locator" : "162:22-162:25",
                        "name" : "PC",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "403",
                        "locator" : "162:32",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "3",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "409",
                  "locator" : "163:5-163:33",
                  "when" : {
                     "localId" : "407",
                     "locator" : "163:10-163:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "405",
                        "locator" : "163:10-163:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "406",
                        "locator" : "163:22-163:26",
                        "name" : "PCM",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "408",
                        "locator" : "163:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "414",
                  "locator" : "164:5-164:33",
                  "when" : {
                     "localId" : "412",
                     "locator" : "164:10-164:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "410",
                        "locator" : "164:10-164:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "411",
                        "locator" : "164:22-164:26",
                        "name" : "PCD",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "413",
                        "locator" : "164:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "419",
                  "locator" : "165:5-165:33",
                  "when" : {
                     "localId" : "417",
                     "locator" : "165:10-165:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "415",
                        "locator" : "165:10-165:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "416",
                        "locator" : "165:22-165:26",
                        "name" : "PCV",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "418",
                        "locator" : "165:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "424",
                  "locator" : "167:5-167:34",
                  "when" : {
                     "localId" : "422",
                     "locator" : "167:10-167:27",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "420",
                        "locator" : "167:10-167:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "421",
                        "locator" : "167:22-167:27",
                        "name" : "MORN",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "423",
                        "locator" : "167:34",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "429",
                  "locator" : "168:5-168:40",
                  "when" : {
                     "localId" : "427",
                     "locator" : "168:10-168:33",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "425",
                        "locator" : "168:10-168:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "426",
                        "locator" : "168:22-168:33",
                        "name" : "MORN.early",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "428",
                        "locator" : "168:40",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "434",
                  "locator" : "169:5-169:39",
                  "when" : {
                     "localId" : "432",
                     "locator" : "169:10-169:32",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "430",
                        "locator" : "169:10-169:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "431",
                        "locator" : "169:22-169:32",
                        "name" : "MORN.late",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "433",
                        "locator" : "169:39",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "439",
                  "locator" : "170:5-170:34",
                  "when" : {
                     "localId" : "437",
                     "locator" : "170:10-170:27",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "435",
                        "locator" : "170:10-170:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "436",
                        "locator" : "170:22-170:27",
                        "name" : "NOON",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "438",
                        "locator" : "170:34",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "444",
                  "locator" : "171:5-171:33",
                  "when" : {
                     "localId" : "442",
                     "locator" : "171:10-171:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "440",
                        "locator" : "171:10-171:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "441",
                        "locator" : "171:22-171:26",
                        "name" : "AFT",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "443",
                        "locator" : "171:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "449",
                  "locator" : "172:5-172:39",
                  "when" : {
                     "localId" : "447",
                     "locator" : "172:10-172:32",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "445",
                        "locator" : "172:10-172:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "446",
                        "locator" : "172:22-172:32",
                        "name" : "AFT.early",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "448",
                        "locator" : "172:39",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "454",
                  "locator" : "173:5-173:38",
                  "when" : {
                     "localId" : "452",
                     "locator" : "173:10-173:31",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "450",
                        "locator" : "173:10-173:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "451",
                        "locator" : "173:22-173:31",
                        "name" : "AFT.late",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "453",
                        "locator" : "173:38",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "459",
                  "locator" : "174:5-174:33",
                  "when" : {
                     "localId" : "457",
                     "locator" : "174:10-174:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "455",
                        "locator" : "174:10-174:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "456",
                        "locator" : "174:22-174:26",
                        "name" : "EVE",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "458",
                        "locator" : "174:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "464",
                  "locator" : "175:5-175:39",
                  "when" : {
                     "localId" : "462",
                     "locator" : "175:10-175:32",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "460",
                        "locator" : "175:10-175:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "461",
                        "locator" : "175:22-175:32",
                        "name" : "EVE.early",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "463",
                        "locator" : "175:39",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "469",
                  "locator" : "176:5-176:38",
                  "when" : {
                     "localId" : "467",
                     "locator" : "176:10-176:31",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "465",
                        "locator" : "176:10-176:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "466",
                        "locator" : "176:22-176:31",
                        "name" : "EVE.late",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "468",
                        "locator" : "176:38",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "474",
                  "locator" : "177:5-177:35",
                  "when" : {
                     "localId" : "472",
                     "locator" : "177:10-177:28",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "470",
                        "locator" : "177:10-177:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "471",
                        "locator" : "177:22-177:28",
                        "name" : "NIGHT",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "473",
                        "locator" : "177:35",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "479",
                  "locator" : "178:5-178:33",
                  "when" : {
                     "localId" : "477",
                     "locator" : "178:10-178:26",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "475",
                        "locator" : "178:10-178:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "476",
                        "locator" : "178:22-178:26",
                        "name" : "PHS",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "478",
                        "locator" : "178:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "1",
                        "type" : "Literal"
                     }
                  }
               }, {
                  "localId" : "484",
                  "locator" : "180:5-180:60",
                  "when" : {
                     "localId" : "482",
                     "locator" : "180:10-180:51",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "480",
                        "locator" : "180:10-180:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "481",
                        "locator" : "180:22-180:51",
                        "name" : "Once daily (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "483",
                     "locator" : "180:58-180:60",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "1.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "489",
                  "locator" : "181:5-181:61",
                  "when" : {
                     "localId" : "487",
                     "locator" : "181:10-181:52",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "485",
                        "locator" : "181:10-181:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "486",
                        "locator" : "181:22-181:52",
                        "name" : "Twice a day (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "488",
                     "locator" : "181:59-181:61",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "2.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "494",
                  "locator" : "182:5-182:67",
                  "when" : {
                     "localId" : "492",
                     "locator" : "182:10-182:58",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "490",
                        "locator" : "182:10-182:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "491",
                        "locator" : "182:22-182:58",
                        "name" : "Three times daily (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "493",
                     "locator" : "182:65-182:67",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "3.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "499",
                  "locator" : "183:5-183:66",
                  "when" : {
                     "localId" : "497",
                     "locator" : "183:10-183:57",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "495",
                        "locator" : "183:10-183:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "496",
                        "locator" : "183:22-183:57",
                        "name" : "Four times daily (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "498",
                     "locator" : "183:64-183:66",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "4.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "504",
                  "locator" : "184:5-184:73",
                  "when" : {
                     "localId" : "502",
                     "locator" : "184:10-184:64",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "500",
                        "locator" : "184:10-184:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "501",
                        "locator" : "184:22-184:64",
                        "name" : "Every twenty four hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "503",
                     "locator" : "184:71-184:73",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "1.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "509",
                  "locator" : "185:5-185:68",
                  "when" : {
                     "localId" : "507",
                     "locator" : "185:10-185:59",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "505",
                        "locator" : "185:10-185:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "506",
                        "locator" : "185:22-185:59",
                        "name" : "Every twelve hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "508",
                     "locator" : "185:66-185:68",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "2.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "514",
                  "locator" : "186:5-186:73",
                  "when" : {
                     "localId" : "512",
                     "locator" : "186:10-186:63",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "510",
                        "locator" : "186:10-186:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "511",
                        "locator" : "186:22-186:63",
                        "name" : "Every thirty six hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "513",
                     "locator" : "186:70-186:73",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "0.67",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "519",
                  "locator" : "187:5-187:67",
                  "when" : {
                     "localId" : "517",
                     "locator" : "187:10-187:58",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "515",
                        "locator" : "187:10-187:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "516",
                        "locator" : "187:22-187:58",
                        "name" : "Every eight hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "518",
                     "locator" : "187:65-187:67",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "3.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "524",
                  "locator" : "188:5-188:66",
                  "when" : {
                     "localId" : "522",
                     "locator" : "188:10-188:57",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "520",
                        "locator" : "188:10-188:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "521",
                        "locator" : "188:22-188:57",
                        "name" : "Every four hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "523",
                     "locator" : "188:64-188:66",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "6.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "529",
                  "locator" : "189:5-189:65",
                  "when" : {
                     "localId" : "527",
                     "locator" : "189:10-189:56",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "525",
                        "locator" : "189:10-189:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "526",
                        "locator" : "189:22-189:56",
                        "name" : "Every six hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "528",
                     "locator" : "189:63-189:65",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "4.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "534",
                  "locator" : "190:5-190:74",
                  "when" : {
                     "localId" : "532",
                     "locator" : "190:10-190:64",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "530",
                        "locator" : "190:10-190:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "531",
                        "locator" : "190:22-190:64",
                        "name" : "Every seventy two hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "533",
                     "locator" : "190:71-190:74",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "0.33",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "539",
                  "locator" : "191:5-191:73",
                  "when" : {
                     "localId" : "537",
                     "locator" : "191:10-191:64",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "535",
                        "locator" : "191:10-191:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "536",
                        "locator" : "191:22-191:64",
                        "name" : "Every forty eight hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "538",
                     "locator" : "191:71-191:73",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "0.5",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "544",
                  "locator" : "192:5-192:77",
                  "when" : {
                     "localId" : "542",
                     "locator" : "192:10-192:68",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "540",
                        "locator" : "192:10-192:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "541",
                        "locator" : "192:22-192:68",
                        "name" : "Every eight to twelve hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "543",
                     "locator" : "192:75-192:77",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "3.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "549",
                  "locator" : "193:5-193:74",
                  "when" : {
                     "localId" : "547",
                     "locator" : "193:10-193:65",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "545",
                        "locator" : "193:10-193:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "546",
                        "locator" : "193:22-193:65",
                        "name" : "Every six to eight hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "548",
                     "locator" : "193:72-193:74",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "4.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "554",
                  "locator" : "194:5-194:75",
                  "when" : {
                     "localId" : "552",
                     "locator" : "194:10-194:66",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "550",
                        "locator" : "194:10-194:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "551",
                        "locator" : "194:22-194:66",
                        "name" : "Every three to four hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "553",
                     "locator" : "194:73-194:75",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "8.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "559",
                  "locator" : "195:5-195:74",
                  "when" : {
                     "localId" : "557",
                     "locator" : "195:10-195:65",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "555",
                        "locator" : "195:10-195:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "556",
                        "locator" : "195:22-195:65",
                        "name" : "Every three to six hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "558",
                     "locator" : "195:72-195:74",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "8.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "564",
                  "locator" : "196:5-196:74",
                  "when" : {
                     "localId" : "562",
                     "locator" : "196:10-196:64",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "560",
                        "locator" : "196:10-196:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "561",
                        "locator" : "196:22-196:64",
                        "name" : "Every two to four hours (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "563",
                     "locator" : "196:71-196:74",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "12.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "569",
                  "locator" : "197:5-197:73",
                  "when" : {
                     "localId" : "567",
                     "locator" : "197:10-197:64",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "565",
                        "locator" : "197:10-197:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "566",
                        "locator" : "197:22-197:64",
                        "name" : "One to four times a day (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "568",
                     "locator" : "197:71-197:73",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "4.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "574",
                  "locator" : "198:5-198:74",
                  "when" : {
                     "localId" : "572",
                     "locator" : "198:10-198:65",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "570",
                        "locator" : "198:10-198:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "571",
                        "locator" : "198:22-198:65",
                        "name" : "One to three times a day (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "573",
                     "locator" : "198:72-198:74",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "3.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "579",
                  "locator" : "199:5-199:72",
                  "when" : {
                     "localId" : "577",
                     "locator" : "199:10-199:63",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "575",
                        "locator" : "199:10-199:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "576",
                        "locator" : "199:22-199:63",
                        "name" : "One to two times a day (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "578",
                     "locator" : "199:70-199:72",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "2.0",
                     "type" : "Literal"
                  }
               }, {
                  "localId" : "584",
                  "locator" : "200:5-200:73",
                  "when" : {
                     "localId" : "582",
                     "locator" : "200:10-200:64",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "580",
                        "locator" : "200:10-200:18",
                        "name" : "frequency",
                        "type" : "OperandRef"
                     }, {
                        "localId" : "581",
                        "locator" : "200:22-200:64",
                        "name" : "Two to four times a day (qualifier value)",
                        "type" : "CodeRef"
                     } ]
                  },
                  "then" : {
                     "localId" : "583",
                     "locator" : "200:71-200:73",
                     "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                     "value" : "4.0",
                     "type" : "Literal"
                  }
               } ],
               "else" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Decimal",
                  "type" : "As",
                  "operand" : {
                     "localId" : "593",
                     "locator" : "202:10-202:125",
                     "type" : "Message",
                     "source" : {
                        "localId" : "585",
                        "locator" : "202:18-202:21",
                        "type" : "Null"
                     },
                     "condition" : {
                        "localId" : "586",
                        "locator" : "202:24-202:27",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "value" : "true",
                        "type" : "Literal"
                     },
                     "code" : {
                        "localId" : "587",
                        "locator" : "202:30-202:68",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "CMDLogic.ToDaily.UnknownFrequencyCode",
                        "type" : "Literal"
                     },
                     "severity" : {
                        "localId" : "588",
                        "locator" : "202:71-202:80",
                        "name" : "ErrorLevel",
                        "type" : "ParameterRef"
                     },
                     "message" : {
                        "localId" : "592",
                        "locator" : "202:83-202:124",
                        "type" : "Concatenate",
                        "operand" : [ {
                           "type" : "Coalesce",
                           "operand" : [ {
                              "localId" : "589",
                              "locator" : "202:83-202:107",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "Unknown frequency code ",
                              "type" : "Literal"
                           }, {
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "",
                              "type" : "Literal"
                           } ]
                        }, {
                           "type" : "Coalesce",
                           "operand" : [ {
                              "localId" : "591",
                              "locator" : "202:111-202:124",
                              "path" : "code",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "590",
                                 "locator" : "202:111-202:119",
                                 "name" : "frequency",
                                 "type" : "OperandRef"
                              }
                           }, {
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "",
                              "type" : "Literal"
                           } ]
                        } ]
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "frequency",
               "operandTypeSpecifier" : {
                  "localId" : "349",
                  "locator" : "150:35-150:38",
                  "name" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "633",
            "locator" : "592:1-596:8",
            "name" : "Quantity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "633",
                  "s" : [ {
                     "value" : [ "/**********************************************************************/\n/* Functions in this region are copied from opioid-mme-r4             */\n/**********************************************************************/\n","define function ","Quantity","(","value"," " ]
                  }, {
                     "r" : "624",
                     "s" : [ {
                        "value" : [ "Decimal" ]
                     } ]
                  }, {
                     "value" : [ ", ","unit"," " ]
                  }, {
                     "r" : "625",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "632",
                     "s" : [ {
                        "r" : "632",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "627",
                           "s" : [ {
                              "r" : "626",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           }, {
                              "value" : [ " is not null" ]
                           } ]
                        }, {
                           "value" : [ " then\n    " ]
                        }, {
                           "r" : "630",
                           "s" : [ {
                              "value" : [ "System",".","Quantity"," { " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "value",": " ]
                              }, {
                                 "r" : "628",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "s" : [ {
                                 "value" : [ "unit",": " ]
                              }, {
                                 "r" : "629",
                                 "s" : [ {
                                    "value" : [ "unit" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " }" ]
                           } ]
                        }, {
                           "r" : "631",
                           "value" : [ "\n  else\n    ","null" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "632",
               "locator" : "593:3-596:8",
               "type" : "If",
               "condition" : {
                  "localId" : "627",
                  "locator" : "593:6-593:22",
                  "type" : "Not",
                  "operand" : {
                     "locator" : "593:6-593:22",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "626",
                        "locator" : "593:6-593:10",
                        "name" : "value",
                        "type" : "OperandRef"
                     }
                  }
               },
               "then" : {
                  "localId" : "630",
                  "locator" : "594:5-594:48",
                  "classType" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "Instance",
                  "element" : [ {
                     "name" : "value",
                     "value" : {
                        "localId" : "628",
                        "locator" : "594:30-594:34",
                        "name" : "value",
                        "type" : "OperandRef"
                     }
                  }, {
                     "name" : "unit",
                     "value" : {
                        "localId" : "629",
                        "locator" : "594:43-594:46",
                        "name" : "unit",
                        "type" : "OperandRef"
                     }
                  } ]
               },
               "else" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "As",
                  "operand" : {
                     "localId" : "631",
                     "locator" : "596:5-596:8",
                     "type" : "Null"
                  }
               }
            },
            "operand" : [ {
               "name" : "value",
               "operandTypeSpecifier" : {
                  "localId" : "624",
                  "locator" : "592:32-592:38",
                  "name" : "{urn:hl7-org:elm-types:r1}Decimal",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "unit",
               "operandTypeSpecifier" : {
                  "localId" : "625",
                  "locator" : "592:46-592:51",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "758",
            "locator" : "284:1-318:13",
            "name" : "MedicationRequestPeriodTest",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "758",
                  "s" : [ {
                     "value" : [ "/*\nNow that we have a ToDaily function, we can approach calculation of the\nduration of medication for an order. First, consider the definitions\nfor each element:\n\n* 1 and only 1 dosageInstruction\n* 1 and only 1 doseAndRate\n* 1 timing with 1 repeat\n* frequency, frequencyMax, defaulting to 1\n* period, periodUnit, defaulting to 1 'd'\n* doseQuantity or doseRange\n* timeOfDay\n\n* authoredOn: The date the prescription was written\n* dispenseRequest.validityPeriod: Time period supply is authorized for\n* dispenseRequest.quantity: amount of medication supplied per dispense\n* dispenseRequest.numberOfRepeatsAllowed: number of refills authorized\n* dispenseRequest.expectedSupplyDuration: number of days supply per dispense\n* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat\n* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat\n* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat\n* dosageInstruction.timing.repeat.count: number of times to repeat\n* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat\n* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period\n* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period\n* dosageInstruction.timing.repeat.period: event occurs frequency times per period\n* dosageInstruction.timing.repeat.periodMax: upper limit of period\n* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a)\n* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*)\n* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...)\n* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD...\n* dosageInstruction.asNeeded\n* dosageInstruction.doseAndRate.doseQuantity\n* dosageInstruction.doseAndRate.doseRange\n\nIf expectedSupplyDuration is present, then the duration is\n\n    expectedSupplyDuration * (1 + numberOfRepeatsAllowed)\n\nIf expectedSupplyDuration is not present, then it must be calculated based on the quantity, dosage, and frequency:\n\n    (quantity / (dosage * frequency)) * (1 + numberOfRepeatsAllowed)\n\n    dosage: Coalesce(end of doseAndRate.doseRange, doseAndRate.doseQuantity)\n    frequency: Coalesce(frequencyMax, frequency)\n    period: Quantity(period, periodUnit)\n\nIf expectedSupplyDuration is not present and cannot be calculated, and the boundsPeriod is present (and completely specified), we can use that directly\n\n    dosage.timing.repeat.boundsPeriod\n\nThis calculation results in a number of days, which can then be turned into a period by anchoring that to the\nstart of the validityPeriod or the authoredOn:\n\n    Interval[earliestDispensable, earliestDispensable + expectedSupplyDuration - 1]\n\n    earliestDispensable: Coalesce(start of validityPeriod, authoredOn)\n\nThe following function illustrates this completely:\n*/\n\n/*\nCalculates the Medication Period for a single MedicationRequest.\nMedicationRequest instances provided to this function are expected\nto conform to the [MMEMedicationRequest](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationrequest.html)\nprofile, which expects:\n* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error\n* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error\n* 1 timing with 1 repeat, missing timing or repeat elements will result in a null\n* frequency, frequencyMax, defaulting to 1\n* period, periodUnit, defaulting to 1 'd'\n* timeOfDay\n* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null\nNote that MedicationRequest status is not considered by this calculation, as the\nlist of MedicationRequest instances provided to this function should already have\nconsidered appropriate statuses, depending on the use case, typically `completed`.\n\nNOTE: Updated return to use \"date from end of boundsPeriod\" to ensure result is Interval<Date>\n*/\n","define function ","MedicationRequestPeriodTest","(","Request"," " ]
                  }, {
                     "r" : "596",
                     "s" : [ {
                        "value" : [ "USCore",".","\"MedicationRequestProfile\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "757",
                     "s" : [ {
                        "r" : "757",
                        "s" : [ {
                           "s" : [ {
                              "r" : "598",
                              "s" : [ {
                                 "r" : "597",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Request" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","R" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "s" : [ {
                              "value" : [ "let\n      " ]
                           }, {
                              "r" : "602",
                              "s" : [ {
                                 "value" : [ "dosage",": " ]
                              }, {
                                 "r" : "601",
                                 "s" : [ {
                                    "value" : [ "singleton from " ]
                                 }, {
                                    "r" : "600",
                                    "s" : [ {
                                       "r" : "599",
                                       "s" : [ {
                                          "value" : [ "R" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "600",
                                       "s" : [ {
                                          "value" : [ "dosageInstruction" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "606",
                              "s" : [ {
                                 "value" : [ "doseAndRate",": " ]
                              }, {
                                 "r" : "605",
                                 "s" : [ {
                                    "value" : [ "singleton from " ]
                                 }, {
                                    "r" : "604",
                                    "s" : [ {
                                       "r" : "603",
                                       "s" : [ {
                                          "value" : [ "dosage" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "604",
                                       "s" : [ {
                                          "value" : [ "doseAndRate" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "609",
                              "s" : [ {
                                 "value" : [ "timing",": " ]
                              }, {
                                 "r" : "608",
                                 "s" : [ {
                                    "r" : "607",
                                    "s" : [ {
                                       "value" : [ "dosage" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "608",
                                    "s" : [ {
                                       "value" : [ "timing" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "617",
                              "s" : [ {
                                 "value" : [ "frequency",": " ]
                              }, {
                                 "r" : "616",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "612",
                                    "s" : [ {
                                       "r" : "611",
                                       "s" : [ {
                                          "r" : "610",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "611",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "612",
                                       "s" : [ {
                                          "value" : [ "frequencyMax" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "615",
                                    "s" : [ {
                                       "r" : "614",
                                       "s" : [ {
                                          "r" : "613",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "614",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "615",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "635",
                              "s" : [ {
                                 "value" : [ "period",": " ]
                              }, {
                                 "r" : "634",
                                 "s" : [ {
                                    "value" : [ "Quantity","(" ]
                                 }, {
                                    "r" : "620",
                                    "s" : [ {
                                       "r" : "619",
                                       "s" : [ {
                                          "r" : "618",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "619",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "620",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "623",
                                    "s" : [ {
                                       "r" : "622",
                                       "s" : [ {
                                          "r" : "621",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "622",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "623",
                                       "s" : [ {
                                          "value" : [ "periodUnit" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "638",
                              "s" : [ {
                                 "value" : [ "doseRange",": " ]
                              }, {
                                 "r" : "637",
                                 "s" : [ {
                                    "r" : "636",
                                    "s" : [ {
                                       "value" : [ "doseAndRate" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "637",
                                    "s" : [ {
                                       "value" : [ "dose" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "641",
                              "s" : [ {
                                 "value" : [ "doseQuantity",": " ]
                              }, {
                                 "r" : "640",
                                 "s" : [ {
                                    "r" : "639",
                                    "s" : [ {
                                       "value" : [ "doseAndRate" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "640",
                                    "s" : [ {
                                       "value" : [ "dose" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "646",
                              "s" : [ {
                                 "value" : [ "dose",": " ]
                              }, {
                                 "r" : "645",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "643",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "642",
                                       "s" : [ {
                                          "value" : [ "doseRange" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "644",
                                    "s" : [ {
                                       "value" : [ "doseQuantity" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "656",
                              "s" : [ {
                                 "value" : [ "dosesPerDay",": " ]
                              }, {
                                 "r" : "655",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "649",
                                    "s" : [ {
                                       "value" : [ "ToDaily","(" ]
                                    }, {
                                       "r" : "647",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "648",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "653",
                                    "s" : [ {
                                       "value" : [ "Count","(" ]
                                    }, {
                                       "r" : "652",
                                       "s" : [ {
                                          "r" : "651",
                                          "s" : [ {
                                             "r" : "650",
                                             "s" : [ {
                                                "value" : [ "timing" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "651",
                                             "s" : [ {
                                                "value" : [ "repeat" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "652",
                                          "s" : [ {
                                             "value" : [ "timeOfDay" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "654",
                                    "value" : [ ", ","1.0",")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "663",
                              "s" : [ {
                                 "value" : [ "boundsPeriod",": " ]
                              }, {
                                 "r" : "662",
                                 "s" : [ {
                                    "r" : "659",
                                    "s" : [ {
                                       "r" : "658",
                                       "s" : [ {
                                          "r" : "657",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "658",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "659",
                                       "s" : [ {
                                          "value" : [ "bounds" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " as " ]
                                 }, {
                                    "r" : "661",
                                    "s" : [ {
                                       "value" : [ "Interval<" ]
                                    }, {
                                       "r" : "660",
                                       "s" : [ {
                                          "value" : [ "DateTime" ]
                                       } ]
                                    }, {
                                       "value" : [ ">" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "668",
                              "s" : [ {
                                 "value" : [ "expectedDaysSupply",": " ]
                              }, {
                                 "r" : "667",
                                 "s" : [ {
                                    "r" : "666",
                                    "s" : [ {
                                       "r" : "665",
                                       "s" : [ {
                                          "r" : "664",
                                          "s" : [ {
                                             "value" : [ "R" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "665",
                                          "s" : [ {
                                             "value" : [ "dispenseRequest" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "666",
                                       "s" : [ {
                                          "value" : [ "expectedSupplyDuration" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "667",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      // TODO: this isn't working as expected, convert results in null\n      //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value,\n      " ]
                           }, {
                              "r" : "673",
                              "s" : [ {
                                 "value" : [ "daysSupply",": " ]
                              }, {
                                 "r" : "672",
                                 "s" : [ {
                                    "r" : "671",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "671",
                                       "s" : [ {
                                          "r" : "670",
                                          "s" : [ {
                                             "r" : "669",
                                             "s" : [ {
                                                "value" : [ "R" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "670",
                                             "s" : [ {
                                                "value" : [ "dispenseRequest" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "671",
                                          "s" : [ {
                                             "value" : [ "expectedSupplyDuration" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "672",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "677",
                              "s" : [ {
                                 "value" : [ "quantity",": " ]
                              }, {
                                 "r" : "676",
                                 "s" : [ {
                                    "r" : "675",
                                    "s" : [ {
                                       "r" : "674",
                                       "s" : [ {
                                          "value" : [ "R" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "675",
                                       "s" : [ {
                                          "value" : [ "dispenseRequest" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "676",
                                    "s" : [ {
                                       "value" : [ "quantity" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "683",
                              "s" : [ {
                                 "value" : [ "refills",": " ]
                              }, {
                                 "r" : "682",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "680",
                                    "s" : [ {
                                       "r" : "679",
                                       "s" : [ {
                                          "r" : "678",
                                          "s" : [ {
                                             "value" : [ "R" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "679",
                                          "s" : [ {
                                             "value" : [ "dispenseRequest" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "680",
                                       "s" : [ {
                                          "value" : [ "numberOfRepeatsAllowed" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "681",
                                    "value" : [ ", ","0",")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "696",
                              "s" : [ {
                                 "value" : [ "startDate",":\n        " ]
                              }, {
                                 "r" : "695",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(\n          " ]
                                 }, {
                                    "r" : "686",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "685",
                                       "s" : [ {
                                          "value" : [ "start of " ]
                                       }, {
                                          "r" : "684",
                                          "s" : [ {
                                             "value" : [ "boundsPeriod" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ",\n          " ]
                                 }, {
                                    "r" : "689",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "688",
                                       "s" : [ {
                                          "r" : "687",
                                          "s" : [ {
                                             "value" : [ "R" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "688",
                                          "s" : [ {
                                             "value" : [ "authoredOn" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ",\n          " ]
                                 }, {
                                    "r" : "694",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "693",
                                       "s" : [ {
                                          "value" : [ "start of " ]
                                       }, {
                                          "r" : "692",
                                          "s" : [ {
                                             "r" : "691",
                                             "s" : [ {
                                                "r" : "690",
                                                "s" : [ {
                                                   "value" : [ "R" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "691",
                                                "s" : [ {
                                                   "value" : [ "dispenseRequest" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "692",
                                             "s" : [ {
                                                "value" : [ "validityPeriod" ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n        )" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "710",
                              "s" : [ {
                                 "value" : [ "totalDaysSupplied",": " ]
                              }, {
                                 "r" : "709",
                                 "s" : [ {
                                    "r" : "705",
                                    "s" : [ {
                                       "value" : [ "Coalesce","(" ]
                                    }, {
                                       "r" : "697",
                                       "s" : [ {
                                          "value" : [ "daysSupply" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "704",
                                       "s" : [ {
                                          "r" : "699",
                                          "s" : [ {
                                             "r" : "698",
                                             "s" : [ {
                                                "value" : [ "quantity" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "699",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " / " ]
                                       }, {
                                          "r" : "703",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "703",
                                             "s" : [ {
                                                "r" : "701",
                                                "s" : [ {
                                                   "r" : "700",
                                                   "s" : [ {
                                                      "value" : [ "dose" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "701",
                                                   "s" : [ {
                                                      "value" : [ "value" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " * " ]
                                             }, {
                                                "r" : "702",
                                                "s" : [ {
                                                   "value" : [ "dosesPerDay" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "708",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "708",
                                       "s" : [ {
                                          "r" : "706",
                                          "value" : [ "1"," + " ]
                                       }, {
                                          "r" : "707",
                                          "s" : [ {
                                             "value" : [ "refills" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "756",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "755",
                              "s" : [ {
                                 "value" : [ "{ " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "dosage",": " ]
                                 }, {
                                    "r" : "711",
                                    "s" : [ {
                                       "value" : [ "dosage" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "doseAndRate",": " ]
                                 }, {
                                    "r" : "712",
                                    "s" : [ {
                                       "value" : [ "doseAndRate" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "timing",": " ]
                                 }, {
                                    "r" : "713",
                                    "s" : [ {
                                       "value" : [ "timing" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "frequency",": " ]
                                 }, {
                                    "r" : "714",
                                    "s" : [ {
                                       "value" : [ "frequency" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "period",": " ]
                                 }, {
                                    "r" : "715",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\n      " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "doseRange",": " ]
                                 }, {
                                    "r" : "716",
                                    "s" : [ {
                                       "value" : [ "doseRange" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "doseQuantity",": " ]
                                 }, {
                                    "r" : "717",
                                    "s" : [ {
                                       "value" : [ "doseQuantity" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "dose",": " ]
                                 }, {
                                    "r" : "718",
                                    "s" : [ {
                                       "value" : [ "dose" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "dosesPerDay",": " ]
                                 }, {
                                    "r" : "719",
                                    "s" : [ {
                                       "value" : [ "dosesPerDay" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "boundsPeriod",": " ]
                                 }, {
                                    "r" : "720",
                                    "s" : [ {
                                       "value" : [ "boundsPeriod" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\n      " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "expectedDaysSupply",": " ]
                                 }, {
                                    "r" : "721",
                                    "s" : [ {
                                       "value" : [ "expectedDaysSupply" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "daysSupply",": " ]
                                 }, {
                                    "r" : "722",
                                    "s" : [ {
                                       "value" : [ "daysSupply" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "quantity",": " ]
                                 }, {
                                    "r" : "723",
                                    "s" : [ {
                                       "value" : [ "quantity" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "refills",": " ]
                                 }, {
                                    "r" : "724",
                                    "s" : [ {
                                       "value" : [ "refills" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "startDate",": " ]
                                 }, {
                                    "r" : "725",
                                    "s" : [ {
                                       "value" : [ "startDate" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "totalDaysSupplied",": " ]
                                 }, {
                                    "r" : "726",
                                    "s" : [ {
                                       "value" : [ "totalDaysSupplied" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\n      " ]
                              }, {
                                 "s" : [ {
                                    "value" : [ "requestPeriod",": " ]
                                 }, {
                                    "r" : "754",
                                    "s" : [ {
                                       "value" : [ "if " ]
                                    }, {
                                       "r" : "731",
                                       "s" : [ {
                                          "r" : "728",
                                          "s" : [ {
                                             "r" : "727",
                                             "s" : [ {
                                                "value" : [ "startDate" ]
                                             } ]
                                          }, {
                                             "value" : [ " is not null" ]
                                          } ]
                                       }, {
                                          "value" : [ " and " ]
                                       }, {
                                          "r" : "730",
                                          "s" : [ {
                                             "r" : "729",
                                             "s" : [ {
                                                "value" : [ "totalDaysSupplied" ]
                                             } ]
                                          }, {
                                             "value" : [ " is not null" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " then\n        " ]
                                    }, {
                                       "r" : "740",
                                       "s" : [ {
                                          "value" : [ "Interval[" ]
                                       }, {
                                          "r" : "732",
                                          "s" : [ {
                                             "value" : [ "startDate" ]
                                          } ]
                                       }, {
                                          "value" : [ ", " ]
                                       }, {
                                          "r" : "739",
                                          "s" : [ {
                                             "r" : "733",
                                             "s" : [ {
                                                "value" : [ "startDate" ]
                                             } ]
                                          }, {
                                             "value" : [ " + " ]
                                          }, {
                                             "r" : "738",
                                             "s" : [ {
                                                "value" : [ "Quantity","(" ]
                                             }, {
                                                "r" : "736",
                                                "s" : [ {
                                                   "r" : "734",
                                                   "s" : [ {
                                                      "value" : [ "totalDaysSupplied" ]
                                                   } ]
                                                }, {
                                                   "r" : "735",
                                                   "value" : [ " - ","1" ]
                                                } ]
                                             }, {
                                                "value" : [ ", " ]
                                             }, {
                                                "r" : "737",
                                                "s" : [ {
                                                   "value" : [ "'day'" ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ]" ]
                                       } ]
                                    }, {
                                       "value" : [ "\n      else " ]
                                    }, {
                                       "r" : "753",
                                       "s" : [ {
                                          "value" : [ "if " ]
                                       }, {
                                          "r" : "746",
                                          "s" : [ {
                                             "r" : "742",
                                             "s" : [ {
                                                "r" : "741",
                                                "s" : [ {
                                                   "value" : [ "startDate" ]
                                                } ]
                                             }, {
                                                "value" : [ " is not null" ]
                                             } ]
                                          }, {
                                             "value" : [ " and " ]
                                          }, {
                                             "r" : "745",
                                             "s" : [ {
                                                "r" : "744",
                                                "s" : [ {
                                                   "r" : "743",
                                                   "s" : [ {
                                                      "value" : [ "boundsPeriod" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "744",
                                                   "s" : [ {
                                                      "value" : [ "\"high\"" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " is not null" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " then\n        " ]
                                       }, {
                                          "r" : "751",
                                          "s" : [ {
                                             "value" : [ "Interval[" ]
                                          }, {
                                             "r" : "747",
                                             "s" : [ {
                                                "value" : [ "startDate" ]
                                             } ]
                                          }, {
                                             "value" : [ ", " ]
                                          }, {
                                             "r" : "750",
                                             "s" : [ {
                                                "value" : [ "date from " ]
                                             }, {
                                                "r" : "749",
                                                "s" : [ {
                                                   "value" : [ "end of " ]
                                                }, {
                                                   "r" : "748",
                                                   "s" : [ {
                                                      "value" : [ "boundsPeriod" ]
                                                   } ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "]" ]
                                          } ]
                                       }, {
                                          "r" : "752",
                                          "value" : [ "\n      else\n        ","null" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "}" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "757",
               "locator" : "285:3-318:13",
               "type" : "Query",
               "source" : [ {
                  "localId" : "598",
                  "locator" : "285:3-285:11",
                  "alias" : "R",
                  "expression" : {
                     "localId" : "597",
                     "locator" : "285:3-285:9",
                     "name" : "Request",
                     "type" : "OperandRef"
                  }
               } ],
               "let" : [ {
                  "localId" : "602",
                  "locator" : "287:7-287:48",
                  "identifier" : "dosage",
                  "expression" : {
                     "localId" : "601",
                     "locator" : "287:15-287:48",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "600",
                        "locator" : "287:30-287:48",
                        "path" : "dosageInstruction",
                        "scope" : "R",
                        "type" : "Property"
                     }
                  }
               }, {
                  "localId" : "606",
                  "locator" : "288:7-288:52",
                  "identifier" : "doseAndRate",
                  "expression" : {
                     "localId" : "605",
                     "locator" : "288:20-288:52",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "604",
                        "locator" : "288:35-288:52",
                        "path" : "doseAndRate",
                        "type" : "Property",
                        "source" : {
                           "localId" : "603",
                           "locator" : "288:35-288:40",
                           "name" : "dosage",
                           "type" : "QueryLetRef"
                        }
                     }
                  }
               }, {
                  "localId" : "609",
                  "locator" : "289:7-289:27",
                  "identifier" : "timing",
                  "expression" : {
                     "localId" : "608",
                     "locator" : "289:15-289:27",
                     "path" : "timing",
                     "type" : "Property",
                     "source" : {
                        "localId" : "607",
                        "locator" : "289:15-289:20",
                        "name" : "dosage",
                        "type" : "QueryLetRef"
                     }
                  }
               }, {
                  "localId" : "617",
                  "locator" : "290:7-290:78",
                  "identifier" : "frequency",
                  "expression" : {
                     "localId" : "616",
                     "locator" : "290:18-290:78",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "612",
                        "locator" : "290:27-290:52",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "frequencyMax",
                           "type" : "Property",
                           "source" : {
                              "localId" : "611",
                              "locator" : "290:27-290:39",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "610",
                                 "locator" : "290:27-290:32",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     }, {
                        "localId" : "615",
                        "locator" : "290:55-290:77",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "frequency",
                           "type" : "Property",
                           "source" : {
                              "localId" : "614",
                              "locator" : "290:55-290:67",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "613",
                                 "locator" : "290:55-290:60",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     } ]
                  }
               }, {
                  "localId" : "635",
                  "locator" : "291:7-291:70",
                  "identifier" : "period",
                  "expression" : {
                     "localId" : "634",
                     "locator" : "291:15-291:70",
                     "name" : "Quantity",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "620",
                        "locator" : "291:24-291:43",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "period",
                           "type" : "Property",
                           "source" : {
                              "localId" : "619",
                              "locator" : "291:24-291:36",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "618",
                                 "locator" : "291:24-291:29",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     }, {
                        "localId" : "623",
                        "locator" : "291:46-291:69",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "periodUnit",
                           "type" : "Property",
                           "source" : {
                              "localId" : "622",
                              "locator" : "291:46-291:58",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "621",
                                 "locator" : "291:46-291:51",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     } ]
                  }
               }, {
                  "localId" : "638",
                  "locator" : "292:7-292:33",
                  "identifier" : "doseRange",
                  "expression" : {
                     "localId" : "637",
                     "locator" : "292:18-292:33",
                     "name" : "ToValue",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "dose",
                        "type" : "Property",
                        "source" : {
                           "localId" : "636",
                           "locator" : "292:18-292:28",
                           "name" : "doseAndRate",
                           "type" : "QueryLetRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "641",
                  "locator" : "293:7-293:36",
                  "identifier" : "doseQuantity",
                  "expression" : {
                     "localId" : "640",
                     "locator" : "293:21-293:36",
                     "name" : "ToValue",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "dose",
                        "type" : "Property",
                        "source" : {
                           "localId" : "639",
                           "locator" : "293:21-293:31",
                           "name" : "doseAndRate",
                           "type" : "QueryLetRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "646",
                  "locator" : "294:7-294:52",
                  "identifier" : "dose",
                  "expression" : {
                     "localId" : "645",
                     "locator" : "294:13-294:52",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "643",
                        "locator" : "294:22-294:37",
                        "type" : "End",
                        "operand" : {
                           "type" : "As",
                           "operand" : {
                              "localId" : "642",
                              "locator" : "294:29-294:37",
                              "name" : "doseRange",
                              "type" : "QueryLetRef"
                           },
                           "asTypeSpecifier" : {
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }
                        }
                     }, {
                        "asType" : "{urn:hl7-org:elm-types:r1}Quantity",
                        "type" : "As",
                        "operand" : {
                           "localId" : "644",
                           "locator" : "294:40-294:51",
                           "name" : "doseQuantity",
                           "type" : "QueryLetRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "656",
                  "locator" : "295:7-295:92",
                  "identifier" : "dosesPerDay",
                  "expression" : {
                     "localId" : "655",
                     "locator" : "295:20-295:92",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "649",
                        "locator" : "295:29-295:54",
                        "name" : "ToDaily",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "647",
                           "locator" : "295:37-295:45",
                           "name" : "frequency",
                           "type" : "QueryLetRef"
                        }, {
                           "localId" : "648",
                           "locator" : "295:48-295:53",
                           "name" : "period",
                           "type" : "QueryLetRef"
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "653",
                           "locator" : "295:57-295:86",
                           "type" : "Count",
                           "source" : {
                              "localId" : "652",
                              "locator" : "295:63-295:85",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "path" : "timeOfDay",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "651",
                                    "locator" : "295:63-295:75",
                                    "path" : "repeat",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "650",
                                       "locator" : "295:63-295:68",
                                       "name" : "timing",
                                       "type" : "QueryLetRef"
                                    }
                                 }
                              }
                           }
                        }
                     }, {
                        "localId" : "654",
                        "locator" : "295:89-295:91",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                        "value" : "1.0",
                        "type" : "Literal"
                     } ]
                  }
               }, {
                  "localId" : "663",
                  "locator" : "296:7-296:62",
                  "identifier" : "boundsPeriod",
                  "expression" : {
                     "localId" : "662",
                     "locator" : "296:21-296:62",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "659",
                        "locator" : "296:21-296:40",
                        "name" : "ToValue",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "bounds",
                           "type" : "Property",
                           "source" : {
                              "localId" : "658",
                              "locator" : "296:21-296:33",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "657",
                                 "locator" : "296:21-296:26",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        } ]
                     },
                     "asTypeSpecifier" : {
                        "localId" : "661",
                        "locator" : "296:45-296:62",
                        "type" : "IntervalTypeSpecifier",
                        "pointType" : {
                           "localId" : "660",
                           "locator" : "296:54-296:61",
                           "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     }
                  }
               }, {
                  "localId" : "668",
                  "locator" : "297:7-297:72",
                  "identifier" : "expectedDaysSupply",
                  "expression" : {
                     "localId" : "667",
                     "locator" : "297:27-297:72",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "666",
                        "locator" : "297:27-297:66",
                        "name" : "ToQuantity",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "expectedSupplyDuration",
                           "type" : "Property",
                           "source" : {
                              "localId" : "665",
                              "locator" : "297:27-297:43",
                              "path" : "dispenseRequest",
                              "scope" : "R",
                              "type" : "Property"
                           }
                        } ]
                     }
                  }
               }, {
                  "localId" : "673",
                  "locator" : "300:7-300:66",
                  "identifier" : "daysSupply",
                  "expression" : {
                     "localId" : "672",
                     "locator" : "300:19-300:66",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "671",
                        "locator" : "300:19-300:60",
                        "name" : "ToQuantity",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "expectedSupplyDuration",
                           "type" : "Property",
                           "source" : {
                              "localId" : "670",
                              "locator" : "300:20-300:36",
                              "path" : "dispenseRequest",
                              "scope" : "R",
                              "type" : "Property"
                           }
                        } ]
                     }
                  }
               }, {
                  "localId" : "677",
                  "locator" : "301:7-301:42",
                  "identifier" : "quantity",
                  "expression" : {
                     "localId" : "676",
                     "locator" : "301:17-301:42",
                     "name" : "ToQuantity",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "quantity",
                        "type" : "Property",
                        "source" : {
                           "localId" : "675",
                           "locator" : "301:17-301:33",
                           "path" : "dispenseRequest",
                           "scope" : "R",
                           "type" : "Property"
                        }
                     } ]
                  }
               }, {
                  "localId" : "683",
                  "locator" : "302:7-302:68",
                  "identifier" : "refills",
                  "expression" : {
                     "localId" : "682",
                     "locator" : "302:16-302:68",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "680",
                        "locator" : "302:25-302:64",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "numberOfRepeatsAllowed",
                           "type" : "Property",
                           "source" : {
                              "localId" : "679",
                              "locator" : "302:25-302:41",
                              "path" : "dispenseRequest",
                              "scope" : "R",
                              "type" : "Property"
                           }
                        }
                     }, {
                        "localId" : "681",
                        "locator" : "302:67",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "0",
                        "type" : "Literal"
                     } ]
                  }
               }, {
                  "localId" : "696",
                  "locator" : "303:7-308:9",
                  "identifier" : "startDate",
                  "expression" : {
                     "localId" : "695",
                     "locator" : "304:9-308:9",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "686",
                        "locator" : "305:11-305:41",
                        "type" : "DateFrom",
                        "operand" : {
                           "localId" : "685",
                           "locator" : "305:21-305:41",
                           "type" : "Start",
                           "operand" : {
                              "localId" : "684",
                              "locator" : "305:30-305:41",
                              "name" : "boundsPeriod",
                              "type" : "QueryLetRef"
                           }
                        }
                     }, {
                        "localId" : "689",
                        "locator" : "306:11-306:32",
                        "type" : "DateFrom",
                        "operand" : {
                           "localId" : "688",
                           "locator" : "306:21-306:32",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "authoredOn",
                              "scope" : "R",
                              "type" : "Property"
                           }
                        }
                     }, {
                        "localId" : "694",
                        "locator" : "307:11-307:61",
                        "type" : "DateFrom",
                        "operand" : {
                           "localId" : "693",
                           "locator" : "307:21-307:61",
                           "type" : "Start",
                           "operand" : {
                              "localId" : "692",
                              "locator" : "307:30-307:61",
                              "name" : "ToInterval",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "path" : "validityPeriod",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "691",
                                    "locator" : "307:30-307:46",
                                    "path" : "dispenseRequest",
                                    "scope" : "R",
                                    "type" : "Property"
                                 }
                              } ]
                           }
                        }
                     } ]
                  }
               }, {
                  "localId" : "710",
                  "locator" : "309:7-309:106",
                  "identifier" : "totalDaysSupplied",
                  "expression" : {
                     "localId" : "709",
                     "locator" : "309:26-309:106",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "705",
                        "locator" : "309:26-309:90",
                        "type" : "Coalesce",
                        "operand" : [ {
                           "localId" : "697",
                           "locator" : "309:35-309:44",
                           "name" : "daysSupply",
                           "type" : "QueryLetRef"
                        }, {
                           "localId" : "704",
                           "locator" : "309:47-309:89",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "699",
                              "locator" : "309:47-309:60",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "698",
                                 "locator" : "309:47-309:54",
                                 "name" : "quantity",
                                 "type" : "QueryLetRef"
                              }
                           }, {
                              "localId" : "703",
                              "locator" : "309:64-309:89",
                              "type" : "Multiply",
                              "operand" : [ {
                                 "localId" : "701",
                                 "locator" : "309:65-309:74",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "700",
                                    "locator" : "309:65-309:68",
                                    "name" : "dose",
                                    "type" : "QueryLetRef"
                                 }
                              }, {
                                 "localId" : "702",
                                 "locator" : "309:78-309:88",
                                 "name" : "dosesPerDay",
                                 "type" : "QueryLetRef"
                              } ]
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "708",
                           "locator" : "309:94-309:106",
                           "type" : "Add",
                           "operand" : [ {
                              "localId" : "706",
                              "locator" : "309:95",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "1",
                              "type" : "Literal"
                           }, {
                              "localId" : "707",
                              "locator" : "309:99-309:105",
                              "name" : "refills",
                              "type" : "QueryLetRef"
                           } ]
                        }
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "756",
                  "locator" : "310:5-318:13",
                  "expression" : {
                     "localId" : "755",
                     "locator" : "310:12-318:13",
                     "type" : "Tuple",
                     "element" : [ {
                        "name" : "dosage",
                        "value" : {
                           "localId" : "711",
                           "locator" : "310:22-310:27",
                           "name" : "dosage",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "doseAndRate",
                        "value" : {
                           "localId" : "712",
                           "locator" : "310:43-310:53",
                           "name" : "doseAndRate",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "timing",
                        "value" : {
                           "localId" : "713",
                           "locator" : "310:64-310:69",
                           "name" : "timing",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "frequency",
                        "value" : {
                           "localId" : "714",
                           "locator" : "310:83-310:91",
                           "name" : "frequency",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "period",
                        "value" : {
                           "localId" : "715",
                           "locator" : "310:102-310:107",
                           "name" : "period",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "doseRange",
                        "value" : {
                           "localId" : "716",
                           "locator" : "311:18-311:26",
                           "name" : "doseRange",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "doseQuantity",
                        "value" : {
                           "localId" : "717",
                           "locator" : "311:43-311:54",
                           "name" : "doseQuantity",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "dose",
                        "value" : {
                           "localId" : "718",
                           "locator" : "311:63-311:66",
                           "name" : "dose",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "dosesPerDay",
                        "value" : {
                           "localId" : "719",
                           "locator" : "311:82-311:92",
                           "name" : "dosesPerDay",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "boundsPeriod",
                        "value" : {
                           "localId" : "720",
                           "locator" : "311:109-311:120",
                           "name" : "boundsPeriod",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "expectedDaysSupply",
                        "value" : {
                           "localId" : "721",
                           "locator" : "312:27-312:44",
                           "name" : "expectedDaysSupply",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "daysSupply",
                        "value" : {
                           "localId" : "722",
                           "locator" : "312:59-312:68",
                           "name" : "daysSupply",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "quantity",
                        "value" : {
                           "localId" : "723",
                           "locator" : "312:81-312:88",
                           "name" : "quantity",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "refills",
                        "value" : {
                           "localId" : "724",
                           "locator" : "312:100-312:106",
                           "name" : "refills",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "startDate",
                        "value" : {
                           "localId" : "725",
                           "locator" : "312:120-312:128",
                           "name" : "startDate",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "totalDaysSupplied",
                        "value" : {
                           "localId" : "726",
                           "locator" : "312:150-312:166",
                           "name" : "totalDaysSupplied",
                           "type" : "QueryLetRef"
                        }
                     }, {
                        "name" : "requestPeriod",
                        "value" : {
                           "localId" : "754",
                           "locator" : "313:22-318:12",
                           "type" : "If",
                           "condition" : {
                              "localId" : "731",
                              "locator" : "313:25-313:79",
                              "type" : "And",
                              "operand" : [ {
                                 "localId" : "728",
                                 "locator" : "313:25-313:45",
                                 "type" : "Not",
                                 "operand" : {
                                    "locator" : "313:25-313:45",
                                    "type" : "IsNull",
                                    "operand" : {
                                       "localId" : "727",
                                       "locator" : "313:25-313:33",
                                       "name" : "startDate",
                                       "type" : "QueryLetRef"
                                    }
                                 }
                              }, {
                                 "localId" : "730",
                                 "locator" : "313:51-313:79",
                                 "type" : "Not",
                                 "operand" : {
                                    "locator" : "313:51-313:79",
                                    "type" : "IsNull",
                                    "operand" : {
                                       "localId" : "729",
                                       "locator" : "313:51-313:67",
                                       "name" : "totalDaysSupplied",
                                       "type" : "QueryLetRef"
                                    }
                                 }
                              } ]
                           },
                           "then" : {
                              "localId" : "740",
                              "locator" : "314:9-314:80",
                              "lowClosed" : true,
                              "highClosed" : true,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "732",
                                 "locator" : "314:18-314:26",
                                 "name" : "startDate",
                                 "type" : "QueryLetRef"
                              },
                              "high" : {
                                 "localId" : "739",
                                 "locator" : "314:29-314:78",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "733",
                                    "locator" : "314:29-314:37",
                                    "name" : "startDate",
                                    "type" : "QueryLetRef"
                                 }, {
                                    "localId" : "738",
                                    "locator" : "314:41-314:78",
                                    "name" : "Quantity",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "736",
                                       "locator" : "314:50-314:70",
                                       "type" : "Subtract",
                                       "operand" : [ {
                                          "localId" : "734",
                                          "locator" : "314:50-314:66",
                                          "name" : "totalDaysSupplied",
                                          "type" : "QueryLetRef"
                                       }, {
                                          "type" : "ToDecimal",
                                          "operand" : {
                                             "localId" : "735",
                                             "locator" : "314:70",
                                             "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                                             "value" : "1",
                                             "type" : "Literal"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "737",
                                       "locator" : "314:73-314:77",
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "day",
                                       "type" : "Literal"
                                    } ]
                                 } ]
                              }
                           },
                           "else" : {
                              "localId" : "753",
                              "locator" : "315:12-318:12",
                              "type" : "If",
                              "condition" : {
                                 "localId" : "746",
                                 "locator" : "315:15-315:71",
                                 "type" : "And",
                                 "operand" : [ {
                                    "localId" : "742",
                                    "locator" : "315:15-315:35",
                                    "type" : "Not",
                                    "operand" : {
                                       "locator" : "315:15-315:35",
                                       "type" : "IsNull",
                                       "operand" : {
                                          "localId" : "741",
                                          "locator" : "315:15-315:23",
                                          "name" : "startDate",
                                          "type" : "QueryLetRef"
                                       }
                                    }
                                 }, {
                                    "localId" : "745",
                                    "locator" : "315:41-315:71",
                                    "type" : "Not",
                                    "operand" : {
                                       "locator" : "315:41-315:71",
                                       "type" : "IsNull",
                                       "operand" : {
                                          "localId" : "744",
                                          "locator" : "315:41-315:59",
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "743",
                                             "locator" : "315:41-315:52",
                                             "name" : "boundsPeriod",
                                             "type" : "QueryLetRef"
                                          }
                                       }
                                    }
                                 } ]
                              },
                              "then" : {
                                 "localId" : "751",
                                 "locator" : "316:9-316:58",
                                 "lowClosed" : true,
                                 "highClosed" : true,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "747",
                                    "locator" : "316:18-316:26",
                                    "name" : "startDate",
                                    "type" : "QueryLetRef"
                                 },
                                 "high" : {
                                    "localId" : "750",
                                    "locator" : "316:29-316:57",
                                    "type" : "DateFrom",
                                    "operand" : {
                                       "localId" : "749",
                                       "locator" : "316:39-316:57",
                                       "type" : "End",
                                       "operand" : {
                                          "localId" : "748",
                                          "locator" : "316:46-316:57",
                                          "name" : "boundsPeriod",
                                          "type" : "QueryLetRef"
                                       }
                                    }
                                 }
                              },
                              "else" : {
                                 "type" : "As",
                                 "operand" : {
                                    "localId" : "752",
                                    "locator" : "318:9-318:12",
                                    "type" : "Null"
                                 },
                                 "asTypeSpecifier" : {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{urn:hl7-org:elm-types:r1}Date",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              }
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "Request",
               "operandTypeSpecifier" : {
                  "localId" : "596",
                  "locator" : "284:53-284:85",
                  "name" : "{http://hl7.org/fhir}MedicationRequest",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "889",
            "locator" : "320:1-351:12",
            "name" : "MedicationRequestPeriod",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "889",
                  "s" : [ {
                     "value" : [ "","define function ","MedicationRequestPeriod","(","Request"," " ]
                  }, {
                     "r" : "759",
                     "s" : [ {
                        "value" : [ "USCore",".","\"MedicationRequestProfile\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "888",
                     "s" : [ {
                        "r" : "888",
                        "s" : [ {
                           "s" : [ {
                              "r" : "761",
                              "s" : [ {
                                 "r" : "760",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Request" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","R" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "s" : [ {
                              "value" : [ "let\n      " ]
                           }, {
                              "r" : "765",
                              "s" : [ {
                                 "value" : [ "dosage",": " ]
                              }, {
                                 "r" : "764",
                                 "s" : [ {
                                    "value" : [ "singleton from " ]
                                 }, {
                                    "r" : "763",
                                    "s" : [ {
                                       "r" : "762",
                                       "s" : [ {
                                          "value" : [ "R" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "763",
                                       "s" : [ {
                                          "value" : [ "dosageInstruction" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "769",
                              "s" : [ {
                                 "value" : [ "doseAndRate",": " ]
                              }, {
                                 "r" : "768",
                                 "s" : [ {
                                    "value" : [ "singleton from " ]
                                 }, {
                                    "r" : "767",
                                    "s" : [ {
                                       "r" : "766",
                                       "s" : [ {
                                          "value" : [ "dosage" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "767",
                                       "s" : [ {
                                          "value" : [ "doseAndRate" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "772",
                              "s" : [ {
                                 "value" : [ "timing",": " ]
                              }, {
                                 "r" : "771",
                                 "s" : [ {
                                    "r" : "770",
                                    "s" : [ {
                                       "value" : [ "dosage" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "771",
                                    "s" : [ {
                                       "value" : [ "timing" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "780",
                              "s" : [ {
                                 "value" : [ "frequency",": " ]
                              }, {
                                 "r" : "779",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "775",
                                    "s" : [ {
                                       "r" : "774",
                                       "s" : [ {
                                          "r" : "773",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "774",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "775",
                                       "s" : [ {
                                          "value" : [ "frequencyMax" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "778",
                                    "s" : [ {
                                       "r" : "777",
                                       "s" : [ {
                                          "r" : "776",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "777",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "778",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "788",
                              "s" : [ {
                                 "value" : [ "period",": " ]
                              }, {
                                 "r" : "787",
                                 "s" : [ {
                                    "value" : [ "Quantity","(" ]
                                 }, {
                                    "r" : "783",
                                    "s" : [ {
                                       "r" : "782",
                                       "s" : [ {
                                          "r" : "781",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "782",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "783",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "786",
                                    "s" : [ {
                                       "r" : "785",
                                       "s" : [ {
                                          "r" : "784",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "785",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "786",
                                       "s" : [ {
                                          "value" : [ "periodUnit" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "791",
                              "s" : [ {
                                 "value" : [ "doseRange",": " ]
                              }, {
                                 "r" : "790",
                                 "s" : [ {
                                    "r" : "789",
                                    "s" : [ {
                                       "value" : [ "doseAndRate" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "790",
                                    "s" : [ {
                                       "value" : [ "dose" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "794",
                              "s" : [ {
                                 "value" : [ "doseQuantity",": " ]
                              }, {
                                 "r" : "793",
                                 "s" : [ {
                                    "r" : "792",
                                    "s" : [ {
                                       "value" : [ "doseAndRate" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "793",
                                    "s" : [ {
                                       "value" : [ "dose" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "799",
                              "s" : [ {
                                 "value" : [ "dose",": " ]
                              }, {
                                 "r" : "798",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "796",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "795",
                                       "s" : [ {
                                          "value" : [ "doseRange" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "797",
                                    "s" : [ {
                                       "value" : [ "doseQuantity" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "809",
                              "s" : [ {
                                 "value" : [ "dosesPerDay",": " ]
                              }, {
                                 "r" : "808",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "802",
                                    "s" : [ {
                                       "value" : [ "ToDaily","(" ]
                                    }, {
                                       "r" : "800",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "801",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "806",
                                    "s" : [ {
                                       "value" : [ "Count","(" ]
                                    }, {
                                       "r" : "805",
                                       "s" : [ {
                                          "r" : "804",
                                          "s" : [ {
                                             "r" : "803",
                                             "s" : [ {
                                                "value" : [ "timing" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "804",
                                             "s" : [ {
                                                "value" : [ "repeat" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "805",
                                          "s" : [ {
                                             "value" : [ "timeOfDay" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "807",
                                    "value" : [ ", ","1.0",")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "816",
                              "s" : [ {
                                 "value" : [ "boundsPeriod",": " ]
                              }, {
                                 "r" : "815",
                                 "s" : [ {
                                    "r" : "812",
                                    "s" : [ {
                                       "r" : "811",
                                       "s" : [ {
                                          "r" : "810",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "811",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "812",
                                       "s" : [ {
                                          "value" : [ "bounds" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " as " ]
                                 }, {
                                    "r" : "814",
                                    "s" : [ {
                                       "value" : [ "Interval<" ]
                                    }, {
                                       "r" : "813",
                                       "s" : [ {
                                          "value" : [ "DateTime" ]
                                       } ]
                                    }, {
                                       "value" : [ ">" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      // TODO: this isn't working as expected, convert results in null\n      //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value,\n      " ]
                           }, {
                              "r" : "821",
                              "s" : [ {
                                 "value" : [ "daysSupply",": " ]
                              }, {
                                 "r" : "820",
                                 "s" : [ {
                                    "r" : "819",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "819",
                                       "s" : [ {
                                          "r" : "818",
                                          "s" : [ {
                                             "r" : "817",
                                             "s" : [ {
                                                "value" : [ "R" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "818",
                                             "s" : [ {
                                                "value" : [ "dispenseRequest" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "819",
                                          "s" : [ {
                                             "value" : [ "expectedSupplyDuration" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "820",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "825",
                              "s" : [ {
                                 "value" : [ "quantity",": " ]
                              }, {
                                 "r" : "824",
                                 "s" : [ {
                                    "r" : "823",
                                    "s" : [ {
                                       "r" : "822",
                                       "s" : [ {
                                          "value" : [ "R" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "823",
                                       "s" : [ {
                                          "value" : [ "dispenseRequest" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "824",
                                    "s" : [ {
                                       "value" : [ "quantity" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "831",
                              "s" : [ {
                                 "value" : [ "refills",": " ]
                              }, {
                                 "r" : "830",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "828",
                                    "s" : [ {
                                       "r" : "827",
                                       "s" : [ {
                                          "r" : "826",
                                          "s" : [ {
                                             "value" : [ "R" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "827",
                                          "s" : [ {
                                             "value" : [ "dispenseRequest" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "828",
                                       "s" : [ {
                                          "value" : [ "numberOfRepeatsAllowed" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "829",
                                    "value" : [ ", ","0",")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "844",
                              "s" : [ {
                                 "value" : [ "startDate",":\n        " ]
                              }, {
                                 "r" : "843",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(\n          " ]
                                 }, {
                                    "r" : "834",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "833",
                                       "s" : [ {
                                          "value" : [ "start of " ]
                                       }, {
                                          "r" : "832",
                                          "s" : [ {
                                             "value" : [ "boundsPeriod" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ",\n          " ]
                                 }, {
                                    "r" : "837",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "836",
                                       "s" : [ {
                                          "r" : "835",
                                          "s" : [ {
                                             "value" : [ "R" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "836",
                                          "s" : [ {
                                             "value" : [ "authoredOn" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ",\n          " ]
                                 }, {
                                    "r" : "842",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "841",
                                       "s" : [ {
                                          "value" : [ "start of " ]
                                       }, {
                                          "r" : "840",
                                          "s" : [ {
                                             "r" : "839",
                                             "s" : [ {
                                                "r" : "838",
                                                "s" : [ {
                                                   "value" : [ "R" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "839",
                                                "s" : [ {
                                                   "value" : [ "dispenseRequest" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "840",
                                             "s" : [ {
                                                "value" : [ "validityPeriod" ]
                                             } ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n        )" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "858",
                              "s" : [ {
                                 "value" : [ "totalDaysSupplied",": " ]
                              }, {
                                 "r" : "857",
                                 "s" : [ {
                                    "r" : "853",
                                    "s" : [ {
                                       "value" : [ "Coalesce","(" ]
                                    }, {
                                       "r" : "845",
                                       "s" : [ {
                                          "value" : [ "daysSupply" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "852",
                                       "s" : [ {
                                          "r" : "847",
                                          "s" : [ {
                                             "r" : "846",
                                             "s" : [ {
                                                "value" : [ "quantity" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "847",
                                             "s" : [ {
                                                "value" : [ "value" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " / " ]
                                       }, {
                                          "r" : "851",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "851",
                                             "s" : [ {
                                                "r" : "849",
                                                "s" : [ {
                                                   "r" : "848",
                                                   "s" : [ {
                                                      "value" : [ "dose" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "849",
                                                   "s" : [ {
                                                      "value" : [ "value" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " * " ]
                                             }, {
                                                "r" : "850",
                                                "s" : [ {
                                                   "value" : [ "dosesPerDay" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ " * " ]
                                 }, {
                                    "r" : "856",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "856",
                                       "s" : [ {
                                          "r" : "854",
                                          "value" : [ "1"," + " ]
                                       }, {
                                          "r" : "855",
                                          "s" : [ {
                                             "value" : [ "refills" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "887",
                           "s" : [ {
                              "value" : [ "return\n      " ]
                           }, {
                              "r" : "886",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "863",
                                 "s" : [ {
                                    "r" : "860",
                                    "s" : [ {
                                       "r" : "859",
                                       "s" : [ {
                                          "value" : [ "startDate" ]
                                       } ]
                                    }, {
                                       "value" : [ " is not null" ]
                                    } ]
                                 }, {
                                    "value" : [ " and " ]
                                 }, {
                                    "r" : "862",
                                    "s" : [ {
                                       "r" : "861",
                                       "s" : [ {
                                          "value" : [ "totalDaysSupplied" ]
                                       } ]
                                    }, {
                                       "value" : [ " is not null" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " then\n        " ]
                              }, {
                                 "r" : "872",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "864",
                                    "s" : [ {
                                       "value" : [ "startDate" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "871",
                                    "s" : [ {
                                       "r" : "865",
                                       "s" : [ {
                                          "value" : [ "startDate" ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "870",
                                       "s" : [ {
                                          "value" : [ "Quantity","(" ]
                                       }, {
                                          "r" : "868",
                                          "s" : [ {
                                             "r" : "866",
                                             "s" : [ {
                                                "value" : [ "totalDaysSupplied" ]
                                             } ]
                                          }, {
                                             "r" : "867",
                                             "value" : [ " - ","1" ]
                                          } ]
                                       }, {
                                          "value" : [ ", " ]
                                       }, {
                                          "r" : "869",
                                          "s" : [ {
                                             "value" : [ "'day'" ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ]" ]
                                 } ]
                              }, {
                                 "value" : [ "\n      else " ]
                              }, {
                                 "r" : "885",
                                 "s" : [ {
                                    "value" : [ "if " ]
                                 }, {
                                    "r" : "878",
                                    "s" : [ {
                                       "r" : "874",
                                       "s" : [ {
                                          "r" : "873",
                                          "s" : [ {
                                             "value" : [ "startDate" ]
                                          } ]
                                       }, {
                                          "value" : [ " is not null" ]
                                       } ]
                                    }, {
                                       "value" : [ " and " ]
                                    }, {
                                       "r" : "877",
                                       "s" : [ {
                                          "r" : "876",
                                          "s" : [ {
                                             "r" : "875",
                                             "s" : [ {
                                                "value" : [ "boundsPeriod" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "876",
                                             "s" : [ {
                                                "value" : [ "\"high\"" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " is not null" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " then\n        " ]
                                 }, {
                                    "r" : "883",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "879",
                                       "s" : [ {
                                          "value" : [ "startDate" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "882",
                                       "s" : [ {
                                          "value" : [ "date from " ]
                                       }, {
                                          "r" : "881",
                                          "s" : [ {
                                             "value" : [ "end of " ]
                                          }, {
                                             "r" : "880",
                                             "s" : [ {
                                                "value" : [ "boundsPeriod" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "]" ]
                                    } ]
                                 }, {
                                    "r" : "884",
                                    "value" : [ "\n      else\n        ","null" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "888",
               "locator" : "321:3-351:12",
               "type" : "Query",
               "source" : [ {
                  "localId" : "761",
                  "locator" : "321:3-321:11",
                  "alias" : "R",
                  "expression" : {
                     "localId" : "760",
                     "locator" : "321:3-321:9",
                     "name" : "Request",
                     "type" : "OperandRef"
                  }
               } ],
               "let" : [ {
                  "localId" : "765",
                  "locator" : "323:7-323:48",
                  "identifier" : "dosage",
                  "expression" : {
                     "localId" : "764",
                     "locator" : "323:15-323:48",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "763",
                        "locator" : "323:30-323:48",
                        "path" : "dosageInstruction",
                        "scope" : "R",
                        "type" : "Property"
                     }
                  }
               }, {
                  "localId" : "769",
                  "locator" : "324:7-324:52",
                  "identifier" : "doseAndRate",
                  "expression" : {
                     "localId" : "768",
                     "locator" : "324:20-324:52",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "767",
                        "locator" : "324:35-324:52",
                        "path" : "doseAndRate",
                        "type" : "Property",
                        "source" : {
                           "localId" : "766",
                           "locator" : "324:35-324:40",
                           "name" : "dosage",
                           "type" : "QueryLetRef"
                        }
                     }
                  }
               }, {
                  "localId" : "772",
                  "locator" : "325:7-325:27",
                  "identifier" : "timing",
                  "expression" : {
                     "localId" : "771",
                     "locator" : "325:15-325:27",
                     "path" : "timing",
                     "type" : "Property",
                     "source" : {
                        "localId" : "770",
                        "locator" : "325:15-325:20",
                        "name" : "dosage",
                        "type" : "QueryLetRef"
                     }
                  }
               }, {
                  "localId" : "780",
                  "locator" : "326:7-326:78",
                  "identifier" : "frequency",
                  "expression" : {
                     "localId" : "779",
                     "locator" : "326:18-326:78",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "775",
                        "locator" : "326:27-326:52",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "frequencyMax",
                           "type" : "Property",
                           "source" : {
                              "localId" : "774",
                              "locator" : "326:27-326:39",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "773",
                                 "locator" : "326:27-326:32",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     }, {
                        "localId" : "778",
                        "locator" : "326:55-326:77",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "frequency",
                           "type" : "Property",
                           "source" : {
                              "localId" : "777",
                              "locator" : "326:55-326:67",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "776",
                                 "locator" : "326:55-326:60",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     } ]
                  }
               }, {
                  "localId" : "788",
                  "locator" : "327:7-327:70",
                  "identifier" : "period",
                  "expression" : {
                     "localId" : "787",
                     "locator" : "327:15-327:70",
                     "name" : "Quantity",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "783",
                        "locator" : "327:24-327:43",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "period",
                           "type" : "Property",
                           "source" : {
                              "localId" : "782",
                              "locator" : "327:24-327:36",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "781",
                                 "locator" : "327:24-327:29",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     }, {
                        "localId" : "786",
                        "locator" : "327:46-327:69",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "periodUnit",
                           "type" : "Property",
                           "source" : {
                              "localId" : "785",
                              "locator" : "327:46-327:58",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "784",
                                 "locator" : "327:46-327:51",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }
                     } ]
                  }
               }, {
                  "localId" : "791",
                  "locator" : "328:7-328:33",
                  "identifier" : "doseRange",
                  "expression" : {
                     "localId" : "790",
                     "locator" : "328:18-328:33",
                     "name" : "ToValue",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "dose",
                        "type" : "Property",
                        "source" : {
                           "localId" : "789",
                           "locator" : "328:18-328:28",
                           "name" : "doseAndRate",
                           "type" : "QueryLetRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "794",
                  "locator" : "329:7-329:36",
                  "identifier" : "doseQuantity",
                  "expression" : {
                     "localId" : "793",
                     "locator" : "329:21-329:36",
                     "name" : "ToValue",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "dose",
                        "type" : "Property",
                        "source" : {
                           "localId" : "792",
                           "locator" : "329:21-329:31",
                           "name" : "doseAndRate",
                           "type" : "QueryLetRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "799",
                  "locator" : "330:7-330:52",
                  "identifier" : "dose",
                  "expression" : {
                     "localId" : "798",
                     "locator" : "330:13-330:52",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "796",
                        "locator" : "330:22-330:37",
                        "type" : "End",
                        "operand" : {
                           "type" : "As",
                           "operand" : {
                              "localId" : "795",
                              "locator" : "330:29-330:37",
                              "name" : "doseRange",
                              "type" : "QueryLetRef"
                           },
                           "asTypeSpecifier" : {
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }
                        }
                     }, {
                        "asType" : "{urn:hl7-org:elm-types:r1}Quantity",
                        "type" : "As",
                        "operand" : {
                           "localId" : "797",
                           "locator" : "330:40-330:51",
                           "name" : "doseQuantity",
                           "type" : "QueryLetRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "809",
                  "locator" : "331:7-331:92",
                  "identifier" : "dosesPerDay",
                  "expression" : {
                     "localId" : "808",
                     "locator" : "331:20-331:92",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "802",
                        "locator" : "331:29-331:54",
                        "name" : "ToDaily",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "800",
                           "locator" : "331:37-331:45",
                           "name" : "frequency",
                           "type" : "QueryLetRef"
                        }, {
                           "localId" : "801",
                           "locator" : "331:48-331:53",
                           "name" : "period",
                           "type" : "QueryLetRef"
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "806",
                           "locator" : "331:57-331:86",
                           "type" : "Count",
                           "source" : {
                              "localId" : "805",
                              "locator" : "331:63-331:85",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "path" : "timeOfDay",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "804",
                                    "locator" : "331:63-331:75",
                                    "path" : "repeat",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "803",
                                       "locator" : "331:63-331:68",
                                       "name" : "timing",
                                       "type" : "QueryLetRef"
                                    }
                                 }
                              }
                           }
                        }
                     }, {
                        "localId" : "807",
                        "locator" : "331:89-331:91",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                        "value" : "1.0",
                        "type" : "Literal"
                     } ]
                  }
               }, {
                  "localId" : "816",
                  "locator" : "332:7-332:62",
                  "identifier" : "boundsPeriod",
                  "expression" : {
                     "localId" : "815",
                     "locator" : "332:21-332:62",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "812",
                        "locator" : "332:21-332:40",
                        "name" : "ToValue",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "bounds",
                           "type" : "Property",
                           "source" : {
                              "localId" : "811",
                              "locator" : "332:21-332:33",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "810",
                                 "locator" : "332:21-332:26",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        } ]
                     },
                     "asTypeSpecifier" : {
                        "localId" : "814",
                        "locator" : "332:45-332:62",
                        "type" : "IntervalTypeSpecifier",
                        "pointType" : {
                           "localId" : "813",
                           "locator" : "332:54-332:61",
                           "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     }
                  }
               }, {
                  "localId" : "821",
                  "locator" : "335:7-335:66",
                  "identifier" : "daysSupply",
                  "expression" : {
                     "localId" : "820",
                     "locator" : "335:19-335:66",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "819",
                        "locator" : "335:19-335:60",
                        "name" : "ToQuantity",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "expectedSupplyDuration",
                           "type" : "Property",
                           "source" : {
                              "localId" : "818",
                              "locator" : "335:20-335:36",
                              "path" : "dispenseRequest",
                              "scope" : "R",
                              "type" : "Property"
                           }
                        } ]
                     }
                  }
               }, {
                  "localId" : "825",
                  "locator" : "336:7-336:42",
                  "identifier" : "quantity",
                  "expression" : {
                     "localId" : "824",
                     "locator" : "336:17-336:42",
                     "name" : "ToQuantity",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "quantity",
                        "type" : "Property",
                        "source" : {
                           "localId" : "823",
                           "locator" : "336:17-336:33",
                           "path" : "dispenseRequest",
                           "scope" : "R",
                           "type" : "Property"
                        }
                     } ]
                  }
               }, {
                  "localId" : "831",
                  "locator" : "337:7-337:68",
                  "identifier" : "refills",
                  "expression" : {
                     "localId" : "830",
                     "locator" : "337:16-337:68",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "828",
                        "locator" : "337:25-337:64",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "numberOfRepeatsAllowed",
                           "type" : "Property",
                           "source" : {
                              "localId" : "827",
                              "locator" : "337:25-337:41",
                              "path" : "dispenseRequest",
                              "scope" : "R",
                              "type" : "Property"
                           }
                        }
                     }, {
                        "localId" : "829",
                        "locator" : "337:67",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                        "value" : "0",
                        "type" : "Literal"
                     } ]
                  }
               }, {
                  "localId" : "844",
                  "locator" : "338:7-343:9",
                  "identifier" : "startDate",
                  "expression" : {
                     "localId" : "843",
                     "locator" : "339:9-343:9",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "834",
                        "locator" : "340:11-340:41",
                        "type" : "DateFrom",
                        "operand" : {
                           "localId" : "833",
                           "locator" : "340:21-340:41",
                           "type" : "Start",
                           "operand" : {
                              "localId" : "832",
                              "locator" : "340:30-340:41",
                              "name" : "boundsPeriod",
                              "type" : "QueryLetRef"
                           }
                        }
                     }, {
                        "localId" : "837",
                        "locator" : "341:11-341:32",
                        "type" : "DateFrom",
                        "operand" : {
                           "localId" : "836",
                           "locator" : "341:21-341:32",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "authoredOn",
                              "scope" : "R",
                              "type" : "Property"
                           }
                        }
                     }, {
                        "localId" : "842",
                        "locator" : "342:11-342:61",
                        "type" : "DateFrom",
                        "operand" : {
                           "localId" : "841",
                           "locator" : "342:21-342:61",
                           "type" : "Start",
                           "operand" : {
                              "localId" : "840",
                              "locator" : "342:30-342:61",
                              "name" : "ToInterval",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "path" : "validityPeriod",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "839",
                                    "locator" : "342:30-342:46",
                                    "path" : "dispenseRequest",
                                    "scope" : "R",
                                    "type" : "Property"
                                 }
                              } ]
                           }
                        }
                     } ]
                  }
               }, {
                  "localId" : "858",
                  "locator" : "344:7-344:106",
                  "identifier" : "totalDaysSupplied",
                  "expression" : {
                     "localId" : "857",
                     "locator" : "344:26-344:106",
                     "type" : "Multiply",
                     "operand" : [ {
                        "localId" : "853",
                        "locator" : "344:26-344:90",
                        "type" : "Coalesce",
                        "operand" : [ {
                           "localId" : "845",
                           "locator" : "344:35-344:44",
                           "name" : "daysSupply",
                           "type" : "QueryLetRef"
                        }, {
                           "localId" : "852",
                           "locator" : "344:47-344:89",
                           "type" : "Divide",
                           "operand" : [ {
                              "localId" : "847",
                              "locator" : "344:47-344:60",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "846",
                                 "locator" : "344:47-344:54",
                                 "name" : "quantity",
                                 "type" : "QueryLetRef"
                              }
                           }, {
                              "localId" : "851",
                              "locator" : "344:64-344:89",
                              "type" : "Multiply",
                              "operand" : [ {
                                 "localId" : "849",
                                 "locator" : "344:65-344:74",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "848",
                                    "locator" : "344:65-344:68",
                                    "name" : "dose",
                                    "type" : "QueryLetRef"
                                 }
                              }, {
                                 "localId" : "850",
                                 "locator" : "344:78-344:88",
                                 "name" : "dosesPerDay",
                                 "type" : "QueryLetRef"
                              } ]
                           } ]
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "856",
                           "locator" : "344:94-344:106",
                           "type" : "Add",
                           "operand" : [ {
                              "localId" : "854",
                              "locator" : "344:95",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "1",
                              "type" : "Literal"
                           }, {
                              "localId" : "855",
                              "locator" : "344:99-344:105",
                              "name" : "refills",
                              "type" : "QueryLetRef"
                           } ]
                        }
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "887",
                  "locator" : "345:5-351:12",
                  "expression" : {
                     "localId" : "886",
                     "locator" : "346:7-351:12",
                     "type" : "If",
                     "condition" : {
                        "localId" : "863",
                        "locator" : "346:10-346:64",
                        "type" : "And",
                        "operand" : [ {
                           "localId" : "860",
                           "locator" : "346:10-346:30",
                           "type" : "Not",
                           "operand" : {
                              "locator" : "346:10-346:30",
                              "type" : "IsNull",
                              "operand" : {
                                 "localId" : "859",
                                 "locator" : "346:10-346:18",
                                 "name" : "startDate",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }, {
                           "localId" : "862",
                           "locator" : "346:36-346:64",
                           "type" : "Not",
                           "operand" : {
                              "locator" : "346:36-346:64",
                              "type" : "IsNull",
                              "operand" : {
                                 "localId" : "861",
                                 "locator" : "346:36-346:52",
                                 "name" : "totalDaysSupplied",
                                 "type" : "QueryLetRef"
                              }
                           }
                        } ]
                     },
                     "then" : {
                        "localId" : "872",
                        "locator" : "347:9-347:80",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "864",
                           "locator" : "347:18-347:26",
                           "name" : "startDate",
                           "type" : "QueryLetRef"
                        },
                        "high" : {
                           "localId" : "871",
                           "locator" : "347:29-347:78",
                           "type" : "Add",
                           "operand" : [ {
                              "localId" : "865",
                              "locator" : "347:29-347:37",
                              "name" : "startDate",
                              "type" : "QueryLetRef"
                           }, {
                              "localId" : "870",
                              "locator" : "347:41-347:78",
                              "name" : "Quantity",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "868",
                                 "locator" : "347:50-347:70",
                                 "type" : "Subtract",
                                 "operand" : [ {
                                    "localId" : "866",
                                    "locator" : "347:50-347:66",
                                    "name" : "totalDaysSupplied",
                                    "type" : "QueryLetRef"
                                 }, {
                                    "type" : "ToDecimal",
                                    "operand" : {
                                       "localId" : "867",
                                       "locator" : "347:70",
                                       "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                                       "value" : "1",
                                       "type" : "Literal"
                                    }
                                 } ]
                              }, {
                                 "localId" : "869",
                                 "locator" : "347:73-347:77",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                 "value" : "day",
                                 "type" : "Literal"
                              } ]
                           } ]
                        }
                     },
                     "else" : {
                        "localId" : "885",
                        "locator" : "348:12-351:12",
                        "type" : "If",
                        "condition" : {
                           "localId" : "878",
                           "locator" : "348:15-348:71",
                           "type" : "And",
                           "operand" : [ {
                              "localId" : "874",
                              "locator" : "348:15-348:35",
                              "type" : "Not",
                              "operand" : {
                                 "locator" : "348:15-348:35",
                                 "type" : "IsNull",
                                 "operand" : {
                                    "localId" : "873",
                                    "locator" : "348:15-348:23",
                                    "name" : "startDate",
                                    "type" : "QueryLetRef"
                                 }
                              }
                           }, {
                              "localId" : "877",
                              "locator" : "348:41-348:71",
                              "type" : "Not",
                              "operand" : {
                                 "locator" : "348:41-348:71",
                                 "type" : "IsNull",
                                 "operand" : {
                                    "localId" : "876",
                                    "locator" : "348:41-348:59",
                                    "path" : "high",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "875",
                                       "locator" : "348:41-348:52",
                                       "name" : "boundsPeriod",
                                       "type" : "QueryLetRef"
                                    }
                                 }
                              }
                           } ]
                        },
                        "then" : {
                           "localId" : "883",
                           "locator" : "349:9-349:58",
                           "lowClosed" : true,
                           "highClosed" : true,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "879",
                              "locator" : "349:18-349:26",
                              "name" : "startDate",
                              "type" : "QueryLetRef"
                           },
                           "high" : {
                              "localId" : "882",
                              "locator" : "349:29-349:57",
                              "type" : "DateFrom",
                              "operand" : {
                                 "localId" : "881",
                                 "locator" : "349:39-349:57",
                                 "type" : "End",
                                 "operand" : {
                                    "localId" : "880",
                                    "locator" : "349:46-349:57",
                                    "name" : "boundsPeriod",
                                    "type" : "QueryLetRef"
                                 }
                              }
                           }
                        },
                        "else" : {
                           "type" : "As",
                           "operand" : {
                              "localId" : "884",
                              "locator" : "351:9-351:12",
                              "type" : "Null"
                           },
                           "asTypeSpecifier" : {
                              "type" : "IntervalTypeSpecifier",
                              "pointType" : {
                                 "name" : "{urn:hl7-org:elm-types:r1}Date",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "Request",
               "operandTypeSpecifier" : {
                  "localId" : "759",
                  "locator" : "320:49-320:81",
                  "name" : "{http://hl7.org/fhir}MedicationRequest",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "983",
            "locator" : "435:1-458:12",
            "name" : "MedicationDispensePeriod",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "983",
                  "s" : [ {
                     "value" : [ "/*\nNext, consider the MedicationDispense case:\n\n* whenPrepared: When product was prepared\n* whenHandedOver: When product was given out\n* quantity: Amount dispensed\n* daysSupply: Amount of medication expressed as a timing amount\n* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat\n* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat\n* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat\n* dosageInstruction.timing.repeat.count: number of times to repeat\n* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat\n* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period\n* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period\n* dosageInstruction.timing.repeat.period: event occurs frequency times per period\n* dosageInstruction.timing.repeat.periodMax: upper limit of period\n* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a)\n* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*)\n* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...)\n* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD...\n* dosageInstruction.asNeeded\n* dosageInstruction.doseAndRate.doseQuantity\n* dosageInstruction.doseAndRate.doseRange\n\nWe have effectively the same elements, with the same meanings, with the exception that the\nevent is documenting a single dispense, and does not contain refill information. In addition,\nmultiple dispense events would typically be present, and those would all have to be considered\nas part of an overall calculation. That will be considered when we combine results, but for\nthis function, we'll focus on calculating the duration of a single dispense.\n\nWith a MedicationDispense, dosage information is expected to be the same as the related\nMedicationRequest, so boundsPeriod would still cover the entire prescription (including refills)\nand so cannot be used to calculate the interval covered by the dispense.\n\nIf the daysSupply element is present, then the duration in days is simply\n\n    daysSupply\n\nNote specifically that we are not considering refills, as those would be covered\nby subsequent dispense records.\n\nIf daysSupplied is not present, then daysSupplied must be calculated based on\nthe quantity, dosage, and frequency:\n\n    (quantity / (dosage * frequency))\n\nThis calculation results in a number of days, which can then be turned into a\nperiod by anchoring that to the startDate, as determined by the first available\nvalue of the start of the boundsPeriod, whenHandedOver, and whenPrepared.\n\n   Interval[startDate, startDate + totalDaysSupplied - 1 day]\n*/\n\n/*\nCalculates Medication Period for a given MedicationDispense\nMedicationDispense instances provided to this function are expected\nto conform to the [TODO: MMEMedicationDispense](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationdispense.html)\nprofile, which expects:\n* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error\n* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error\n* 1 timing with 1 repeat, missing timing or repeat elements will result in a null\n* frequency, frequencyMax, defaulting to 1\n* period, periodUnit, defaulting to 1 'd'\n* timeOfDay\n* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null\n* whenHandedOver or whenPrepared, if missing both whenHandedOver and whenPrepared will result in a null\n\nNote that MedicationDispense status is not considered by this calculation, as the\nlist of MedicationDispense instances provided to this function should already have\nconsidered appropriate statuses, depending on the use case, typically `completed`,\nespecially since whenHandedOver would be expected to be present for a completed\nMedicationDispense.\n\nNote also that the dosage information recorded in a dispense is expected to be a copy of the\ndispense information from the related medication request. As such, the boundsPeriod would be expected\nto cover the entire range, and should _not_ be used for timing of the event.\n\nThere is also active discussion in the Pharmacy WG about what date should be used if whenPrepared/whenHandedOver is not present.\nThis may take the form of an \"original creation date\", but may also be a \"status change date\" for dispense events that are updating\nstatus of an existing dispense. That discussion is ongoing, so until that is resolved, this logic will return\nnull if whenPrepared/whenHandedOver are not available.\n*/\n","define function ","MedicationDispensePeriod","(","Dispense"," " ]
                  }, {
                     "r" : "890",
                     "s" : [ {
                        "value" : [ "\"MedicationDispense\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "982",
                     "s" : [ {
                        "r" : "982",
                        "s" : [ {
                           "s" : [ {
                              "r" : "892",
                              "s" : [ {
                                 "r" : "891",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Dispense" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","D" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "s" : [ {
                              "value" : [ "let\n      " ]
                           }, {
                              "r" : "896",
                              "s" : [ {
                                 "value" : [ "dosage",": " ]
                              }, {
                                 "r" : "895",
                                 "s" : [ {
                                    "value" : [ "singleton from " ]
                                 }, {
                                    "r" : "894",
                                    "s" : [ {
                                       "r" : "893",
                                       "s" : [ {
                                          "value" : [ "D" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "894",
                                       "s" : [ {
                                          "value" : [ "dosageInstruction" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "900",
                              "s" : [ {
                                 "value" : [ "doseAndRate",": " ]
                              }, {
                                 "r" : "899",
                                 "s" : [ {
                                    "value" : [ "singleton from " ]
                                 }, {
                                    "r" : "898",
                                    "s" : [ {
                                       "r" : "897",
                                       "s" : [ {
                                          "value" : [ "dosage" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "898",
                                       "s" : [ {
                                          "value" : [ "doseAndRate" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "903",
                              "s" : [ {
                                 "value" : [ "timing",": " ]
                              }, {
                                 "r" : "902",
                                 "s" : [ {
                                    "r" : "901",
                                    "s" : [ {
                                       "value" : [ "dosage" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "902",
                                    "s" : [ {
                                       "value" : [ "timing" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "911",
                              "s" : [ {
                                 "value" : [ "frequency",": " ]
                              }, {
                                 "r" : "910",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "906",
                                    "s" : [ {
                                       "r" : "905",
                                       "s" : [ {
                                          "r" : "904",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "905",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "906",
                                       "s" : [ {
                                          "value" : [ "frequencyMax" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "909",
                                    "s" : [ {
                                       "r" : "908",
                                       "s" : [ {
                                          "r" : "907",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "908",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "909",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "919",
                              "s" : [ {
                                 "value" : [ "period",": " ]
                              }, {
                                 "r" : "918",
                                 "s" : [ {
                                    "value" : [ "Quantity","(" ]
                                 }, {
                                    "r" : "914",
                                    "s" : [ {
                                       "r" : "913",
                                       "s" : [ {
                                          "r" : "912",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "913",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "914",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "917",
                                    "s" : [ {
                                       "r" : "916",
                                       "s" : [ {
                                          "r" : "915",
                                          "s" : [ {
                                             "value" : [ "timing" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "916",
                                          "s" : [ {
                                             "value" : [ "repeat" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "917",
                                       "s" : [ {
                                          "value" : [ "periodUnit" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "922",
                              "s" : [ {
                                 "value" : [ "doseRange",": " ]
                              }, {
                                 "r" : "921",
                                 "s" : [ {
                                    "r" : "920",
                                    "s" : [ {
                                       "value" : [ "doseAndRate" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "921",
                                    "s" : [ {
                                       "value" : [ "dose" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "925",
                              "s" : [ {
                                 "value" : [ "doseQuantity",": " ]
                              }, {
                                 "r" : "924",
                                 "s" : [ {
                                    "r" : "923",
                                    "s" : [ {
                                       "value" : [ "doseAndRate" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "924",
                                    "s" : [ {
                                       "value" : [ "dose" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "930",
                              "s" : [ {
                                 "value" : [ "dose",": " ]
                              }, {
                                 "r" : "929",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "927",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "926",
                                       "s" : [ {
                                          "value" : [ "doseRange" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "928",
                                    "s" : [ {
                                       "value" : [ "doseQuantity" ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "935",
                              "s" : [ {
                                 "value" : [ "daysSupply",": " ]
                              }, {
                                 "r" : "934",
                                 "s" : [ {
                                    "r" : "933",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "933",
                                       "s" : [ {
                                          "value" : [ "convert " ]
                                       }, {
                                          "r" : "932",
                                          "s" : [ {
                                             "r" : "931",
                                             "s" : [ {
                                                "value" : [ "D" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "932",
                                             "s" : [ {
                                                "value" : [ "daysSupply" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " to ","days" ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "934",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "945",
                              "s" : [ {
                                 "value" : [ "dosesPerDay",": " ]
                              }, {
                                 "r" : "944",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "938",
                                    "s" : [ {
                                       "value" : [ "ToDaily","(" ]
                                    }, {
                                       "r" : "936",
                                       "s" : [ {
                                          "value" : [ "frequency" ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "937",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "942",
                                    "s" : [ {
                                       "value" : [ "Count","(" ]
                                    }, {
                                       "r" : "941",
                                       "s" : [ {
                                          "r" : "940",
                                          "s" : [ {
                                             "r" : "939",
                                             "s" : [ {
                                                "value" : [ "timing" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "940",
                                             "s" : [ {
                                                "value" : [ "repeat" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "941",
                                          "s" : [ {
                                             "value" : [ "timeOfDay" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "943",
                                    "value" : [ ", ","1.0",")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "953",
                              "s" : [ {
                                 "value" : [ "startDate",":\n        " ]
                              }, {
                                 "r" : "952",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(\n          " ]
                                 }, {
                                    "r" : "948",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "947",
                                       "s" : [ {
                                          "r" : "946",
                                          "s" : [ {
                                             "value" : [ "D" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "947",
                                          "s" : [ {
                                             "value" : [ "whenHandedOver" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ",\n          " ]
                                 }, {
                                    "r" : "951",
                                    "s" : [ {
                                       "value" : [ "date from " ]
                                    }, {
                                       "r" : "950",
                                       "s" : [ {
                                          "r" : "949",
                                          "s" : [ {
                                             "value" : [ "D" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "950",
                                          "s" : [ {
                                             "value" : [ "whenPrepared" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n        )" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "964",
                              "s" : [ {
                                 "value" : [ "totalDaysSupplied",": " ]
                              }, {
                                 "r" : "963",
                                 "s" : [ {
                                    "value" : [ "Coalesce","(" ]
                                 }, {
                                    "r" : "954",
                                    "s" : [ {
                                       "value" : [ "daysSupply" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "962",
                                    "s" : [ {
                                       "r" : "957",
                                       "s" : [ {
                                          "r" : "956",
                                          "s" : [ {
                                             "r" : "955",
                                             "s" : [ {
                                                "value" : [ "D" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "956",
                                             "s" : [ {
                                                "value" : [ "quantity" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "957",
                                          "s" : [ {
                                             "value" : [ "value" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " / " ]
                                    }, {
                                       "r" : "961",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "961",
                                          "s" : [ {
                                             "r" : "959",
                                             "s" : [ {
                                                "r" : "958",
                                                "s" : [ {
                                                   "value" : [ "dose" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "959",
                                                "s" : [ {
                                                   "value" : [ "value" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " * " ]
                                          }, {
                                             "r" : "960",
                                             "s" : [ {
                                                "value" : [ "dosesPerDay" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "981",
                           "s" : [ {
                              "value" : [ "return\n      " ]
                           }, {
                              "r" : "980",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "969",
                                 "s" : [ {
                                    "r" : "966",
                                    "s" : [ {
                                       "r" : "965",
                                       "s" : [ {
                                          "value" : [ "startDate" ]
                                       } ]
                                    }, {
                                       "value" : [ " is not null" ]
                                    } ]
                                 }, {
                                    "value" : [ " and " ]
                                 }, {
                                    "r" : "968",
                                    "s" : [ {
                                       "r" : "967",
                                       "s" : [ {
                                          "value" : [ "totalDaysSupplied" ]
                                       } ]
                                    }, {
                                       "value" : [ " is not null" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " then\n        " ]
                              }, {
                                 "r" : "978",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "970",
                                    "s" : [ {
                                       "value" : [ "startDate" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "977",
                                    "s" : [ {
                                       "r" : "971",
                                       "s" : [ {
                                          "value" : [ "startDate" ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "976",
                                       "s" : [ {
                                          "value" : [ "Quantity","(" ]
                                       }, {
                                          "r" : "974",
                                          "s" : [ {
                                             "r" : "972",
                                             "s" : [ {
                                                "value" : [ "totalDaysSupplied" ]
                                             } ]
                                          }, {
                                             "r" : "973",
                                             "value" : [ " - ","1" ]
                                          } ]
                                       }, {
                                          "value" : [ ", " ]
                                       }, {
                                          "r" : "975",
                                          "s" : [ {
                                             "value" : [ "'day'" ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              }, {
                                 "r" : "979",
                                 "value" : [ "\n      else\n        ","null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "982",
               "locator" : "436:3-458:12",
               "type" : "Query",
               "source" : [ {
                  "localId" : "892",
                  "locator" : "436:3-436:12",
                  "alias" : "D",
                  "expression" : {
                     "localId" : "891",
                     "locator" : "436:3-436:10",
                     "name" : "Dispense",
                     "type" : "OperandRef"
                  }
               } ],
               "let" : [ {
                  "localId" : "896",
                  "locator" : "438:7-438:48",
                  "identifier" : "dosage",
                  "expression" : {
                     "localId" : "895",
                     "locator" : "438:15-438:48",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "894",
                        "locator" : "438:30-438:48",
                        "path" : "dosageInstruction",
                        "scope" : "D",
                        "type" : "Property"
                     }
                  }
               }, {
                  "localId" : "900",
                  "locator" : "439:7-439:52",
                  "identifier" : "doseAndRate",
                  "expression" : {
                     "localId" : "899",
                     "locator" : "439:20-439:52",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "localId" : "898",
                        "locator" : "439:35-439:52",
                        "path" : "doseAndRate",
                        "type" : "Property",
                        "source" : {
                           "localId" : "897",
                           "locator" : "439:35-439:40",
                           "name" : "dosage",
                           "type" : "QueryLetRef"
                        }
                     }
                  }
               }, {
                  "localId" : "903",
                  "locator" : "440:7-440:27",
                  "identifier" : "timing",
                  "expression" : {
                     "localId" : "902",
                     "locator" : "440:15-440:27",
                     "path" : "timing",
                     "type" : "Property",
                     "source" : {
                        "localId" : "901",
                        "locator" : "440:15-440:20",
                        "name" : "dosage",
                        "type" : "QueryLetRef"
                     }
                  }
               }, {
                  "localId" : "911",
                  "locator" : "441:7-441:78",
                  "identifier" : "frequency",
                  "expression" : {
                     "localId" : "910",
                     "locator" : "441:18-441:78",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "906",
                        "locator" : "441:27-441:52",
                        "path" : "frequencyMax",
                        "type" : "Property",
                        "source" : {
                           "localId" : "905",
                           "locator" : "441:27-441:39",
                           "path" : "repeat",
                           "type" : "Property",
                           "source" : {
                              "localId" : "904",
                              "locator" : "441:27-441:32",
                              "name" : "timing",
                              "type" : "QueryLetRef"
                           }
                        }
                     }, {
                        "localId" : "909",
                        "locator" : "441:55-441:77",
                        "path" : "frequency",
                        "type" : "Property",
                        "source" : {
                           "localId" : "908",
                           "locator" : "441:55-441:67",
                           "path" : "repeat",
                           "type" : "Property",
                           "source" : {
                              "localId" : "907",
                              "locator" : "441:55-441:60",
                              "name" : "timing",
                              "type" : "QueryLetRef"
                           }
                        }
                     } ]
                  }
               }, {
                  "localId" : "919",
                  "locator" : "442:7-442:70",
                  "identifier" : "period",
                  "expression" : {
                     "localId" : "918",
                     "locator" : "442:15-442:70",
                     "name" : "Quantity",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "name" : "ToDecimal",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "914",
                           "locator" : "442:24-442:43",
                           "path" : "period",
                           "type" : "Property",
                           "source" : {
                              "localId" : "913",
                              "locator" : "442:24-442:36",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "912",
                                 "locator" : "442:24-442:29",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        } ]
                     }, {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "917",
                           "locator" : "442:46-442:69",
                           "path" : "periodUnit",
                           "type" : "Property",
                           "source" : {
                              "localId" : "916",
                              "locator" : "442:46-442:58",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "915",
                                 "locator" : "442:46-442:51",
                                 "name" : "timing",
                                 "type" : "QueryLetRef"
                              }
                           }
                        } ]
                     } ]
                  }
               }, {
                  "localId" : "922",
                  "locator" : "443:7-443:33",
                  "identifier" : "doseRange",
                  "expression" : {
                     "localId" : "921",
                     "locator" : "443:18-443:33",
                     "path" : "dose",
                     "type" : "Property",
                     "source" : {
                        "localId" : "920",
                        "locator" : "443:18-443:28",
                        "name" : "doseAndRate",
                        "type" : "QueryLetRef"
                     }
                  }
               }, {
                  "localId" : "925",
                  "locator" : "444:7-444:36",
                  "identifier" : "doseQuantity",
                  "expression" : {
                     "localId" : "924",
                     "locator" : "444:21-444:36",
                     "path" : "dose",
                     "type" : "Property",
                     "source" : {
                        "localId" : "923",
                        "locator" : "444:21-444:31",
                        "name" : "doseAndRate",
                        "type" : "QueryLetRef"
                     }
                  }
               }, {
                  "localId" : "930",
                  "locator" : "445:7-445:52",
                  "identifier" : "dose",
                  "expression" : {
                     "localId" : "929",
                     "locator" : "445:13-445:52",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "927",
                        "locator" : "445:22-445:37",
                        "type" : "End",
                        "operand" : {
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "asType" : "{http://hl7.org/fhir}Range",
                              "type" : "As",
                              "operand" : {
                                 "localId" : "926",
                                 "locator" : "445:29-445:37",
                                 "name" : "doseRange",
                                 "type" : "QueryLetRef"
                              }
                           } ]
                        }
                     }, {
                        "type" : "ToQuantity",
                        "operand" : {
                           "localId" : "928",
                           "locator" : "445:40-445:51",
                           "name" : "doseQuantity",
                           "type" : "QueryLetRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "935",
                  "locator" : "446:7-446:54",
                  "identifier" : "daysSupply",
                  "expression" : {
                     "localId" : "934",
                     "locator" : "446:19-446:54",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "933",
                        "locator" : "446:19-446:48",
                        "type" : "ConvertQuantity",
                        "operand" : [ {
                           "name" : "ToQuantity",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "932",
                              "locator" : "446:28-446:39",
                              "path" : "daysSupply",
                              "scope" : "D",
                              "type" : "Property"
                           } ]
                        }, {
                           "locator" : "446:44-446:47",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "d",
                           "type" : "Literal"
                        } ]
                     }
                  }
               }, {
                  "localId" : "945",
                  "locator" : "447:7-447:92",
                  "identifier" : "dosesPerDay",
                  "expression" : {
                     "localId" : "944",
                     "locator" : "447:20-447:92",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "938",
                        "locator" : "447:29-447:54",
                        "name" : "ToDaily",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "name" : "ToInteger",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "936",
                              "locator" : "447:37-447:45",
                              "name" : "frequency",
                              "type" : "QueryLetRef"
                           } ]
                        }, {
                           "localId" : "937",
                           "locator" : "447:48-447:53",
                           "name" : "period",
                           "type" : "QueryLetRef"
                        } ]
                     }, {
                        "type" : "ToDecimal",
                        "operand" : {
                           "localId" : "942",
                           "locator" : "447:57-447:86",
                           "type" : "Count",
                           "source" : {
                              "localId" : "941",
                              "locator" : "447:63-447:85",
                              "path" : "timeOfDay",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "940",
                                 "locator" : "447:63-447:75",
                                 "path" : "repeat",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "939",
                                    "locator" : "447:63-447:68",
                                    "name" : "timing",
                                    "type" : "QueryLetRef"
                                 }
                              }
                           }
                        }
                     }, {
                        "localId" : "943",
                        "locator" : "447:89-447:91",
                        "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                        "value" : "1.0",
                        "type" : "Literal"
                     } ]
                  }
               }, {
                  "localId" : "953",
                  "locator" : "448:7-452:9",
                  "identifier" : "startDate",
                  "expression" : {
                     "localId" : "952",
                     "locator" : "449:9-452:9",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "948",
                        "locator" : "450:11-450:36",
                        "type" : "DateFrom",
                        "operand" : {
                           "name" : "ToDateTime",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "947",
                              "locator" : "450:21-450:36",
                              "path" : "whenHandedOver",
                              "scope" : "D",
                              "type" : "Property"
                           } ]
                        }
                     }, {
                        "localId" : "951",
                        "locator" : "451:11-451:34",
                        "type" : "DateFrom",
                        "operand" : {
                           "name" : "ToDateTime",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "950",
                              "locator" : "451:21-451:34",
                              "path" : "whenPrepared",
                              "scope" : "D",
                              "type" : "Property"
                           } ]
                        }
                     } ]
                  }
               }, {
                  "localId" : "964",
                  "locator" : "453:7-453:92",
                  "identifier" : "totalDaysSupplied",
                  "expression" : {
                     "localId" : "963",
                     "locator" : "453:26-453:92",
                     "type" : "Coalesce",
                     "operand" : [ {
                        "localId" : "954",
                        "locator" : "453:35-453:44",
                        "name" : "daysSupply",
                        "type" : "QueryLetRef"
                     }, {
                        "localId" : "962",
                        "locator" : "453:47-453:91",
                        "type" : "Divide",
                        "operand" : [ {
                           "name" : "ToDecimal",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "957",
                              "locator" : "453:47-453:62",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "956",
                                 "locator" : "453:47-453:56",
                                 "path" : "quantity",
                                 "scope" : "D",
                                 "type" : "Property"
                              }
                           } ]
                        }, {
                           "localId" : "961",
                           "locator" : "453:66-453:91",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "959",
                              "locator" : "453:67-453:76",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "958",
                                 "locator" : "453:67-453:70",
                                 "name" : "dose",
                                 "type" : "QueryLetRef"
                              }
                           }, {
                              "localId" : "960",
                              "locator" : "453:80-453:90",
                              "name" : "dosesPerDay",
                              "type" : "QueryLetRef"
                           } ]
                        } ]
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "981",
                  "locator" : "454:5-458:12",
                  "expression" : {
                     "localId" : "980",
                     "locator" : "455:7-458:12",
                     "type" : "If",
                     "condition" : {
                        "localId" : "969",
                        "locator" : "455:10-455:64",
                        "type" : "And",
                        "operand" : [ {
                           "localId" : "966",
                           "locator" : "455:10-455:30",
                           "type" : "Not",
                           "operand" : {
                              "locator" : "455:10-455:30",
                              "type" : "IsNull",
                              "operand" : {
                                 "localId" : "965",
                                 "locator" : "455:10-455:18",
                                 "name" : "startDate",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }, {
                           "localId" : "968",
                           "locator" : "455:36-455:64",
                           "type" : "Not",
                           "operand" : {
                              "locator" : "455:36-455:64",
                              "type" : "IsNull",
                              "operand" : {
                                 "localId" : "967",
                                 "locator" : "455:36-455:52",
                                 "name" : "totalDaysSupplied",
                                 "type" : "QueryLetRef"
                              }
                           }
                        } ]
                     },
                     "then" : {
                        "localId" : "978",
                        "locator" : "456:9-456:79",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "970",
                           "locator" : "456:18-456:26",
                           "name" : "startDate",
                           "type" : "QueryLetRef"
                        },
                        "high" : {
                           "localId" : "977",
                           "locator" : "456:29-456:78",
                           "type" : "Add",
                           "operand" : [ {
                              "localId" : "971",
                              "locator" : "456:29-456:37",
                              "name" : "startDate",
                              "type" : "QueryLetRef"
                           }, {
                              "localId" : "976",
                              "locator" : "456:41-456:78",
                              "name" : "Quantity",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "974",
                                 "locator" : "456:50-456:70",
                                 "type" : "Subtract",
                                 "operand" : [ {
                                    "localId" : "972",
                                    "locator" : "456:50-456:66",
                                    "name" : "totalDaysSupplied",
                                    "type" : "QueryLetRef"
                                 }, {
                                    "type" : "ToDecimal",
                                    "operand" : {
                                       "localId" : "973",
                                       "locator" : "456:70",
                                       "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                                       "value" : "1",
                                       "type" : "Literal"
                                    }
                                 } ]
                              }, {
                                 "localId" : "975",
                                 "locator" : "456:73-456:77",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                 "value" : "day",
                                 "type" : "Literal"
                              } ]
                           } ]
                        }
                     },
                     "else" : {
                        "type" : "As",
                        "operand" : {
                           "localId" : "979",
                           "locator" : "458:9-458:12",
                           "type" : "Null"
                        },
                        "asTypeSpecifier" : {
                           "type" : "IntervalTypeSpecifier",
                           "pointType" : {
                              "name" : "{urn:hl7-org:elm-types:r1}Date",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "Dispense",
               "operandTypeSpecifier" : {
                  "localId" : "890",
                  "locator" : "435:51-435:70",
                  "name" : "{http://hl7.org/fhir}MedicationDispense",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "986",
            "locator" : "466:1-467:9",
            "name" : "TherapeuticDuration",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "986",
                  "s" : [ {
                     "value" : [ "/*\nReturns the established therapeutic duration for a given medication.\nThis is likely measure specific, though could potentially be established for\nany drug and distributed as a CodeSystem supplement.\nDefaulting to 14 days here for illustration.\n*/\n","define function ","TherapeuticDuration","(","medication"," " ]
                  }, {
                     "r" : "984",
                     "s" : [ {
                        "value" : [ "Concept" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "985",
                     "s" : [ {
                        "r" : "985",
                        "s" : [ {
                           "value" : [ "14 ","days" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "985",
               "locator" : "467:3-467:9",
               "value" : 14,
               "unit" : "days",
               "type" : "Quantity"
            },
            "operand" : [ {
               "name" : "medication",
               "operandTypeSpecifier" : {
                  "localId" : "984",
                  "locator" : "466:48-466:54",
                  "name" : "{urn:hl7-org:elm-types:r1}Concept",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1015",
            "locator" : "491:1-500:12",
            "name" : "MedicationAdministrationPeriod",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1015",
                  "s" : [ {
                     "value" : [ "/*\nNext we consider MedicationAdministration. This data type is typically used to\ncapture specific administration, with the relevantPeriod capturing start and stop\ntime of the administration event:\n\n* effective[x]: Start and end time of administration\n\nHowever, when calculating cumulative medication duration, it is typically the\ntherapeutic period of the medication that should be considered. Currently neither\nthe Medication nor MedicationKnowledge resources provide this information, so\nwe model it here as a function that can potentially be implemented in a variety\nof ways, including measure-specific values, as well as distribution as an RxNorm\ncode system supplement.\n\nHowever it is obtained, if therapeutic duration can be obtained, and the effective\nperiod has a start, the result will be\n\n    Interval[startDate, startDate + therapeuticDuration - 1 day]\n\nNOTE: Therapeutic duration needs to be established and until a way is implemented to\ndo that based on the medication, this logic is incomplete and should not be used.\n*/\n","define function ","MedicationAdministrationPeriod","(","Administration"," " ]
                  }, {
                     "r" : "987",
                     "s" : [ {
                        "value" : [ "\"MedicationAdministration\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1014",
                     "s" : [ {
                        "r" : "1014",
                        "s" : [ {
                           "s" : [ {
                              "r" : "989",
                              "s" : [ {
                                 "r" : "988",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Administration" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","M" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "s" : [ {
                              "value" : [ "let\n      " ]
                           }, {
                              "r" : "993",
                              "s" : [ {
                                 "value" : [ "therapeuticDuration",": " ]
                              }, {
                                 "r" : "992",
                                 "s" : [ {
                                    "value" : [ "TherapeuticDuration","(" ]
                                 }, {
                                    "r" : "991",
                                    "s" : [ {
                                       "r" : "990",
                                       "s" : [ {
                                          "value" : [ "Administration" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "991",
                                       "s" : [ {
                                          "value" : [ "medication" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ",\n      " ]
                           }, {
                              "r" : "998",
                              "s" : [ {
                                 "value" : [ "startDate",": " ]
                              }, {
                                 "r" : "997",
                                 "s" : [ {
                                    "value" : [ "date from " ]
                                 }, {
                                    "r" : "996",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "995",
                                       "s" : [ {
                                          "r" : "994",
                                          "s" : [ {
                                             "value" : [ "Administration" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "995",
                                          "s" : [ {
                                             "value" : [ "effective" ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "1013",
                           "s" : [ {
                              "value" : [ "return\n      " ]
                           }, {
                              "r" : "1012",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "1003",
                                 "s" : [ {
                                    "r" : "1000",
                                    "s" : [ {
                                       "r" : "999",
                                       "s" : [ {
                                          "value" : [ "startDate" ]
                                       } ]
                                    }, {
                                       "value" : [ " is not null" ]
                                    } ]
                                 }, {
                                    "value" : [ " and " ]
                                 }, {
                                    "r" : "1002",
                                    "s" : [ {
                                       "r" : "1001",
                                       "s" : [ {
                                          "value" : [ "therapeuticDuration" ]
                                       } ]
                                    }, {
                                       "value" : [ " is not null" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " then\n        " ]
                              }, {
                                 "r" : "1010",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "1004",
                                    "s" : [ {
                                       "value" : [ "startDate" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "1009",
                                    "s" : [ {
                                       "r" : "1007",
                                       "s" : [ {
                                          "r" : "1005",
                                          "s" : [ {
                                             "value" : [ "startDate" ]
                                          } ]
                                       }, {
                                          "value" : [ " + " ]
                                       }, {
                                          "r" : "1006",
                                          "s" : [ {
                                             "value" : [ "therapeuticDuration" ]
                                          } ]
                                       } ]
                                    }, {
                                       "r" : "1008",
                                       "value" : [ " - ","1" ]
                                    } ]
                                 }, {
                                    "value" : [ "]" ]
                                 } ]
                              }, {
                                 "r" : "1011",
                                 "value" : [ "\n      else\n        ","null" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1014",
               "locator" : "492:3-500:12",
               "type" : "Query",
               "source" : [ {
                  "localId" : "989",
                  "locator" : "492:3-492:18",
                  "alias" : "M",
                  "expression" : {
                     "localId" : "988",
                     "locator" : "492:3-492:16",
                     "name" : "Administration",
                     "type" : "OperandRef"
                  }
               } ],
               "let" : [ {
                  "localId" : "993",
                  "locator" : "494:7-494:73",
                  "identifier" : "therapeuticDuration",
                  "expression" : {
                     "localId" : "992",
                     "locator" : "494:28-494:73",
                     "name" : "TherapeuticDuration",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "name" : "ToConcept",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "asType" : "{http://hl7.org/fhir}CodeableConcept",
                           "type" : "As",
                           "operand" : {
                              "localId" : "991",
                              "locator" : "494:48-494:72",
                              "path" : "medication",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "990",
                                 "locator" : "494:48-494:61",
                                 "name" : "Administration",
                                 "type" : "OperandRef"
                              }
                           }
                        } ]
                     } ]
                  }
               }, {
                  "localId" : "998",
                  "locator" : "495:7-495:60",
                  "identifier" : "startDate",
                  "expression" : {
                     "localId" : "997",
                     "locator" : "495:18-495:60",
                     "type" : "DateFrom",
                     "operand" : {
                        "localId" : "996",
                        "locator" : "495:28-495:60",
                        "type" : "Start",
                        "operand" : {
                           "name" : "ToInterval",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "asType" : "{http://hl7.org/fhir}Period",
                              "type" : "As",
                              "operand" : {
                                 "localId" : "995",
                                 "locator" : "495:37-495:60",
                                 "path" : "effective",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "994",
                                    "locator" : "495:37-495:50",
                                    "name" : "Administration",
                                    "type" : "OperandRef"
                                 }
                              }
                           } ]
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "1013",
                  "locator" : "496:5-500:12",
                  "expression" : {
                     "localId" : "1012",
                     "locator" : "497:7-500:12",
                     "type" : "If",
                     "condition" : {
                        "localId" : "1003",
                        "locator" : "497:10-497:66",
                        "type" : "And",
                        "operand" : [ {
                           "localId" : "1000",
                           "locator" : "497:10-497:30",
                           "type" : "Not",
                           "operand" : {
                              "locator" : "497:10-497:30",
                              "type" : "IsNull",
                              "operand" : {
                                 "localId" : "999",
                                 "locator" : "497:10-497:18",
                                 "name" : "startDate",
                                 "type" : "QueryLetRef"
                              }
                           }
                        }, {
                           "localId" : "1002",
                           "locator" : "497:36-497:66",
                           "type" : "Not",
                           "operand" : {
                              "locator" : "497:36-497:66",
                              "type" : "IsNull",
                              "operand" : {
                                 "localId" : "1001",
                                 "locator" : "497:36-497:54",
                                 "name" : "therapeuticDuration",
                                 "type" : "QueryLetRef"
                              }
                           }
                        } ]
                     },
                     "then" : {
                        "localId" : "1010",
                        "locator" : "498:9-498:64",
                        "lowClosed" : true,
                        "highClosed" : true,
                        "type" : "Interval",
                        "low" : {
                           "localId" : "1004",
                           "locator" : "498:18-498:26",
                           "name" : "startDate",
                           "type" : "QueryLetRef"
                        },
                        "high" : {
                           "localId" : "1009",
                           "locator" : "498:29-498:63",
                           "type" : "Subtract",
                           "operand" : [ {
                              "localId" : "1007",
                              "locator" : "498:29-498:59",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "1005",
                                 "locator" : "498:29-498:37",
                                 "name" : "startDate",
                                 "type" : "QueryLetRef"
                              }, {
                                 "localId" : "1006",
                                 "locator" : "498:41-498:59",
                                 "name" : "therapeuticDuration",
                                 "type" : "QueryLetRef"
                              } ]
                           }, {
                              "type" : "ToQuantity",
                              "operand" : {
                                 "localId" : "1008",
                                 "locator" : "498:63",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                                 "value" : "1",
                                 "type" : "Literal"
                              }
                           } ]
                        }
                     },
                     "else" : {
                        "type" : "As",
                        "operand" : {
                           "localId" : "1011",
                           "locator" : "500:9-500:12",
                           "type" : "Null"
                        },
                        "asTypeSpecifier" : {
                           "type" : "IntervalTypeSpecifier",
                           "pointType" : {
                              "name" : "{urn:hl7-org:elm-types:r1}Date",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "Administration",
               "operandTypeSpecifier" : {
                  "localId" : "987",
                  "locator" : "491:63-491:88",
                  "name" : "{http://hl7.org/fhir}MedicationAdministration",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "1036",
            "locator" : "516:1-523:13",
            "name" : "CumulativeDuration",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1036",
                  "s" : [ {
                     "value" : [ "/*\nNow that we have functions for determining the medication period for individual\nprescriptions, administrations, and dispenses, we can combine those using\nan overall cumulative medication duration calculation.\n\nThere are two broad approaches to calculating cumulative duration, one that _collapses_\noverlapping intervals so that calculations are not duplicated, and one that _rolls out_\noverlapping intervals so that the durations are laid end-to-end.\n\nFirst, we define a function that simply calculates CumulativeDuration of a set of\nintervals:\n\nNOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>>\n*/\n","define function ","CumulativeDuration","(","Intervals"," " ]
                  }, {
                     "r" : "1018",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1017",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "1016",
                           "s" : [ {
                              "value" : [ "Date" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n   " ]
                  }, {
                     "r" : "1035",
                     "s" : [ {
                        "r" : "1035",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "1020",
                           "s" : [ {
                              "r" : "1019",
                              "s" : [ {
                                 "value" : [ "Intervals" ]
                              } ]
                           }, {
                              "value" : [ " is not null" ]
                           } ]
                        }, {
                           "value" : [ " then " ]
                        }, {
                           "r" : "1033",
                           "s" : [ {
                              "value" : [ "( " ]
                           }, {
                              "r" : "1033",
                              "s" : [ {
                                 "value" : [ "Sum","(" ]
                              }, {
                                 "r" : "1032",
                                 "s" : [ {
                                    "s" : [ {
                                       "r" : "1023",
                                       "s" : [ {
                                          "r" : "1022",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "1022",
                                             "s" : [ {
                                                "value" : [ "collapse " ]
                                             }, {
                                                "r" : "1021",
                                                "s" : [ {
                                                   "value" : [ "Intervals" ]
                                                } ]
                                             }, {
                                                "value" : [ " per ","day" ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       }, {
                                          "value" : [ "X" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n        " ]
                                 }, {
                                    "r" : "1031",
                                    "s" : [ {
                                       "value" : [ "return all" ]
                                    }, {
                                       "r" : "1030",
                                       "s" : [ {
                                          "r" : "1028",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "1028",
                                             "s" : [ {
                                                "value" : [ "difference in days between " ]
                                             }, {
                                                "r" : "1025",
                                                "s" : [ {
                                                   "value" : [ "start of " ]
                                                }, {
                                                   "r" : "1024",
                                                   "s" : [ {
                                                      "value" : [ "X" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " and \n          " ]
                                             }, {
                                                "r" : "1027",
                                                "s" : [ {
                                                   "value" : [ "end of " ]
                                                }, {
                                                   "r" : "1026",
                                                   "s" : [ {
                                                      "value" : [ "X" ]
                                                   } ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "\n        )" ]
                                          } ]
                                       }, {
                                          "r" : "1029",
                                          "value" : [ "+ ","1" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    )" ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        }, {
                           "r" : "1034",
                           "value" : [ " \n    else ","null" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1035",
               "locator" : "517:4-523:13",
               "type" : "If",
               "condition" : {
                  "localId" : "1020",
                  "locator" : "517:7-517:27",
                  "type" : "Not",
                  "operand" : {
                     "locator" : "517:7-517:27",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "1019",
                        "locator" : "517:7-517:15",
                        "name" : "Intervals",
                        "type" : "OperandRef"
                     }
                  }
               },
               "then" : {
                  "localId" : "1033",
                  "locator" : "517:34-522:3",
                  "type" : "Sum",
                  "source" : {
                     "localId" : "1032",
                     "locator" : "517:40-520:12",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "1023",
                        "locator" : "517:40-517:68",
                        "alias" : "X",
                        "expression" : {
                           "localId" : "1022",
                           "locator" : "517:40-517:67",
                           "type" : "Collapse",
                           "operand" : [ {
                              "localId" : "1021",
                              "locator" : "517:50-517:58",
                              "name" : "Intervals",
                              "type" : "OperandRef"
                           }, {
                              "value" : 1.0,
                              "unit" : "day",
                              "type" : "Quantity"
                           } ]
                        }
                     } ],
                     "relationship" : [ ],
                     "return" : {
                        "localId" : "1031",
                        "locator" : "518:9-520:12",
                        "distinct" : false,
                        "expression" : {
                           "localId" : "1030",
                           "locator" : "518:19-520:12",
                           "type" : "Add",
                           "operand" : [ {
                              "localId" : "1028",
                              "locator" : "518:19-520:9",
                              "precision" : "Day",
                              "type" : "DifferenceBetween",
                              "operand" : [ {
                                 "localId" : "1025",
                                 "locator" : "518:47-518:56",
                                 "type" : "Start",
                                 "operand" : {
                                    "localId" : "1024",
                                    "locator" : "518:56",
                                    "name" : "X",
                                    "type" : "AliasRef"
                                 }
                              }, {
                                 "localId" : "1027",
                                 "locator" : "519:11-519:18",
                                 "type" : "End",
                                 "operand" : {
                                    "localId" : "1026",
                                    "locator" : "519:18",
                                    "name" : "X",
                                    "type" : "AliasRef"
                                 }
                              } ]
                           }, {
                              "localId" : "1029",
                              "locator" : "520:12",
                              "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                              "value" : "1",
                              "type" : "Literal"
                           } ]
                        }
                     }
                  }
               },
               "else" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Integer",
                  "type" : "As",
                  "operand" : {
                     "localId" : "1034",
                     "locator" : "523:10-523:13",
                     "type" : "Null"
                  }
               }
            },
            "operand" : [ {
               "name" : "Intervals",
               "operandTypeSpecifier" : {
                  "localId" : "1018",
                  "locator" : "516:46-516:65",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1017",
                     "locator" : "516:51-516:64",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "1016",
                        "locator" : "516:60-516:63",
                        "name" : "{urn:hl7-org:elm-types:r1}Date",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            } ]
         }, {
            "localId" : "1078",
            "locator" : "530:1-538:5",
            "name" : "RolloutIntervals",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1078",
                  "s" : [ {
                     "value" : [ "/*\nNext, we define a function that rolls out intervals:\n\nNOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>>\n*/\n","define function ","RolloutIntervals","(","intervals"," " ]
                  }, {
                     "r" : "1039",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1038",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "1037",
                           "s" : [ {
                              "value" : [ "Date" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n " ]
                  }, {
                     "r" : "1077",
                     "s" : [ {
                        "r" : "1077",
                        "s" : [ {
                           "s" : [ {
                              "r" : "1041",
                              "s" : [ {
                                 "r" : "1040",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "intervals" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","I" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " " ]
                        }, {
                           "r" : "1076",
                           "s" : [ {
                              "value" : [ "aggregate all ","R"," " ]
                           }, {
                              "r" : "1046",
                              "s" : [ {
                                 "value" : [ "starting ( " ]
                              }, {
                                 "r" : "1046",
                                 "s" : [ {
                                    "r" : "1042",
                                    "value" : [ "null"," as " ]
                                 }, {
                                    "r" : "1045",
                                    "s" : [ {
                                       "value" : [ "List<" ]
                                    }, {
                                       "r" : "1044",
                                       "s" : [ {
                                          "value" : [ "Interval<" ]
                                       }, {
                                          "r" : "1043",
                                          "s" : [ {
                                             "value" : [ "Date" ]
                                          } ]
                                       }, {
                                          "value" : [ ">" ]
                                       } ]
                                    }, {
                                       "value" : [ ">" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ ": " ]
                           }, {
                              "r" : "1075",
                              "s" : [ {
                                 "r" : "1047",
                                 "s" : [ {
                                    "value" : [ "R" ]
                                 } ]
                              }, {
                                 "value" : [ "\n    union " ]
                              }, {
                                 "r" : "1074",
                                 "s" : [ {
                                    "value" : [ "( " ]
                                 }, {
                                    "r" : "1074",
                                    "s" : [ {
                                       "value" : [ "{ " ]
                                    }, {
                                       "r" : "1073",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "1049",
                                             "s" : [ {
                                                "r" : "1048",
                                                "s" : [ {
                                                   "s" : [ {
                                                      "value" : [ "I" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","X" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "s" : [ {
                                             "value" : [ "let " ]
                                          }, {
                                             "r" : "1059",
                                             "s" : [ {
                                                "value" : [ "S",": " ]
                                             }, {
                                                "r" : "1058",
                                                "s" : [ {
                                                   "value" : [ "Max","(" ]
                                                }, {
                                                   "r" : "1057",
                                                   "s" : [ {
                                                      "value" : [ "{ \n          " ]
                                                   }, {
                                                      "r" : "1054",
                                                      "s" : [ {
                                                         "r" : "1052",
                                                         "s" : [ {
                                                            "value" : [ "end of " ]
                                                         }, {
                                                            "r" : "1051",
                                                            "s" : [ {
                                                               "value" : [ "Last","(" ]
                                                            }, {
                                                               "r" : "1050",
                                                               "s" : [ {
                                                                  "value" : [ "R" ]
                                                               } ]
                                                            }, {
                                                               "value" : [ ")" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "+ " ]
                                                      }, {
                                                         "r" : "1053",
                                                         "s" : [ {
                                                            "value" : [ "1 ","day" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ ", " ]
                                                   }, {
                                                      "r" : "1056",
                                                      "s" : [ {
                                                         "value" : [ "start of " ]
                                                      }, {
                                                         "r" : "1055",
                                                         "s" : [ {
                                                            "value" : [ "X" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " }" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n        )" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ",\n        " ]
                                          }, {
                                             "r" : "1068",
                                             "s" : [ {
                                                "value" : [ "E",": " ]
                                             }, {
                                                "r" : "1067",
                                                "s" : [ {
                                                   "r" : "1060",
                                                   "s" : [ {
                                                      "value" : [ "S" ]
                                                   } ]
                                                }, {
                                                   "value" : [ " + " ]
                                                }, {
                                                   "r" : "1066",
                                                   "s" : [ {
                                                      "value" : [ "Quantity","(" ]
                                                   }, {
                                                      "r" : "1064",
                                                      "s" : [ {
                                                         "value" : [ "Coalesce","(" ]
                                                      }, {
                                                         "r" : "1062",
                                                         "s" : [ {
                                                            "value" : [ "duration in days of " ]
                                                         }, {
                                                            "r" : "1061",
                                                            "s" : [ {
                                                               "value" : [ "X" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "r" : "1063",
                                                         "value" : [ ", ","0",")" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ ", " ]
                                                   }, {
                                                      "r" : "1065",
                                                      "s" : [ {
                                                         "value" : [ "'day'" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ ")" ]
                                                   } ]
                                                } ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "1072",
                                          "s" : [ {
                                             "value" : [ "return " ]
                                          }, {
                                             "r" : "1071",
                                             "s" : [ {
                                                "value" : [ "Interval[" ]
                                             }, {
                                                "r" : "1069",
                                                "s" : [ {
                                                   "value" : [ "S" ]
                                                } ]
                                             }, {
                                                "value" : [ ", " ]
                                             }, {
                                                "r" : "1070",
                                                "s" : [ {
                                                   "value" : [ "E" ]
                                                } ]
                                             }, {
                                                "value" : [ "]" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "}" ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    )" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1077",
               "locator" : "531:2-538:5",
               "type" : "Query",
               "source" : [ {
                  "localId" : "1041",
                  "locator" : "531:2-531:12",
                  "alias" : "I",
                  "expression" : {
                     "localId" : "1040",
                     "locator" : "531:2-531:10",
                     "name" : "intervals",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "aggregate" : {
                  "localId" : "1076",
                  "locator" : "531:14-538:5",
                  "identifier" : "R",
                  "distinct" : false,
                  "expression" : {
                     "localId" : "1075",
                     "locator" : "531:72-538:5",
                     "type" : "Union",
                     "operand" : [ {
                        "localId" : "1047",
                        "locator" : "531:72",
                        "name" : "R",
                        "type" : "QueryLetRef"
                     }, {
                        "localId" : "1074",
                        "locator" : "532:11-538:5",
                        "type" : "List",
                        "element" : [ {
                           "localId" : "1073",
                           "locator" : "532:15-537:29",
                           "type" : "Query",
                           "source" : [ {
                              "localId" : "1049",
                              "locator" : "532:15-532:17",
                              "alias" : "X",
                              "expression" : {
                                 "localId" : "1048",
                                 "locator" : "532:15",
                                 "name" : "I",
                                 "type" : "AliasRef"
                              }
                           } ],
                           "let" : [ {
                              "localId" : "1059",
                              "locator" : "533:13-535:9",
                              "identifier" : "S",
                              "expression" : {
                                 "localId" : "1058",
                                 "locator" : "533:16-535:9",
                                 "type" : "Max",
                                 "source" : {
                                    "localId" : "1057",
                                    "locator" : "533:20-534:45",
                                    "type" : "List",
                                    "element" : [ {
                                       "localId" : "1054",
                                       "locator" : "534:11-534:31",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "1052",
                                          "locator" : "534:11-534:24",
                                          "type" : "End",
                                          "operand" : {
                                             "localId" : "1051",
                                             "locator" : "534:18-534:24",
                                             "type" : "Last",
                                             "source" : {
                                                "localId" : "1050",
                                                "locator" : "534:23",
                                                "name" : "R",
                                                "type" : "QueryLetRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "1053",
                                          "locator" : "534:27-534:31",
                                          "value" : 1,
                                          "unit" : "day",
                                          "type" : "Quantity"
                                       } ]
                                    }, {
                                       "localId" : "1056",
                                       "locator" : "534:34-534:43",
                                       "type" : "Start",
                                       "operand" : {
                                          "localId" : "1055",
                                          "locator" : "534:43",
                                          "name" : "X",
                                          "type" : "AliasRef"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "localId" : "1068",
                              "locator" : "536:9-536:66",
                              "identifier" : "E",
                              "expression" : {
                                 "localId" : "1067",
                                 "locator" : "536:12-536:66",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "1060",
                                    "locator" : "536:12",
                                    "name" : "S",
                                    "type" : "QueryLetRef"
                                 }, {
                                    "localId" : "1066",
                                    "locator" : "536:16-536:66",
                                    "name" : "Quantity",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "type" : "ToDecimal",
                                       "operand" : {
                                          "localId" : "1064",
                                          "locator" : "536:25-536:58",
                                          "type" : "Coalesce",
                                          "operand" : [ {
                                             "localId" : "1062",
                                             "locator" : "536:34-536:54",
                                             "precision" : "Day",
                                             "type" : "DurationBetween",
                                             "operand" : [ {
                                                "type" : "Start",
                                                "operand" : {
                                                   "localId" : "1061",
                                                   "locator" : "536:54",
                                                   "name" : "X",
                                                   "type" : "AliasRef"
                                                }
                                             }, {
                                                "type" : "End",
                                                "operand" : {
                                                   "localId" : "1061",
                                                   "locator" : "536:54",
                                                   "name" : "X",
                                                   "type" : "AliasRef"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "1063",
                                             "locator" : "536:57",
                                             "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                                             "value" : "0",
                                             "type" : "Literal"
                                          } ]
                                       }
                                    }, {
                                       "localId" : "1065",
                                       "locator" : "536:61-536:65",
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "day",
                                       "type" : "Literal"
                                    } ]
                                 } ]
                              }
                           } ],
                           "relationship" : [ ],
                           "return" : {
                              "localId" : "1072",
                              "locator" : "537:9-537:29",
                              "expression" : {
                                 "localId" : "1071",
                                 "locator" : "537:16-537:29",
                                 "lowClosed" : true,
                                 "highClosed" : true,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "1069",
                                    "locator" : "537:25",
                                    "name" : "S",
                                    "type" : "QueryLetRef"
                                 },
                                 "high" : {
                                    "localId" : "1070",
                                    "locator" : "537:28",
                                    "name" : "E",
                                    "type" : "QueryLetRef"
                                 }
                              }
                           }
                        } ]
                     } ]
                  },
                  "starting" : {
                     "localId" : "1046",
                     "locator" : "531:30-531:69",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "1042",
                        "locator" : "531:41-531:44",
                        "type" : "Null"
                     },
                     "asTypeSpecifier" : {
                        "localId" : "1045",
                        "locator" : "531:49-531:68",
                        "type" : "ListTypeSpecifier",
                        "elementType" : {
                           "localId" : "1044",
                           "locator" : "531:54-531:67",
                           "type" : "IntervalTypeSpecifier",
                           "pointType" : {
                              "localId" : "1043",
                              "locator" : "531:63-531:66",
                              "name" : "{urn:hl7-org:elm-types:r1}Date",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "intervals",
               "operandTypeSpecifier" : {
                  "localId" : "1039",
                  "locator" : "530:44-530:63",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1038",
                     "locator" : "530:49-530:62",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "1037",
                        "locator" : "530:58-530:61",
                        "name" : "{urn:hl7-org:elm-types:r1}Date",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            } ]
         }, {
            "localId" : "1096",
            "locator" : "545:1-553:5",
            "name" : "MedicationPeriod",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1096",
                  "s" : [ {
                     "value" : [ "/*\nThen, we define a function that allows us to calculate based on the various medication\ntypes:\n*/\n","define function ","MedicationPeriod","(\n  ","medication"," " ]
                  }, {
                     "r" : "1081",
                     "s" : [ {
                        "value" : [ "Choice<" ]
                     }, {
                        "r" : "1079",
                        "s" : [ {
                           "value" : [ "USCore",".","\"MedicationRequestProfile\"" ]
                        } ]
                     }, {
                        "value" : [ ",\n    " ]
                     }, {
                        "r" : "1080",
                        "s" : [ {
                           "value" : [ "\"MedicationDispense\"" ]
                        } ]
                     }, {
                        "value" : [ "\n  >" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1095",
                     "s" : [ {
                        "r" : "1095",
                        "s" : [ {
                           "value" : [ "case\n    " ]
                        }, {
                           "r" : "1087",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "1084",
                              "s" : [ {
                                 "r" : "1082",
                                 "s" : [ {
                                    "value" : [ "medication" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "1083",
                                 "s" : [ {
                                    "value" : [ "USCore",".","\"MedicationRequestProfile\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "1086",
                              "s" : [ {
                                 "value" : [ "MedicationRequestPeriod","(" ]
                              }, {
                                 "r" : "1085",
                                 "s" : [ {
                                    "value" : [ "medication" ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "1093",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "1090",
                              "s" : [ {
                                 "r" : "1088",
                                 "s" : [ {
                                    "value" : [ "medication" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "1089",
                                 "s" : [ {
                                    "value" : [ "MedicationDispense" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then " ]
                           }, {
                              "r" : "1092",
                              "s" : [ {
                                 "value" : [ "MedicationDispensePeriod","(" ]
                              }, {
                                 "r" : "1091",
                                 "s" : [ {
                                    "value" : [ "medication" ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "r" : "1094",
                           "value" : [ "\n    else ","null","\n  end" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1095",
               "locator" : "549:3-553:5",
               "type" : "Case",
               "caseItem" : [ {
                  "localId" : "1087",
                  "locator" : "550:5-550:97",
                  "when" : {
                     "localId" : "1084",
                     "locator" : "550:10-550:56",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "1082",
                        "locator" : "550:10-550:19",
                        "name" : "medication",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "1083",
                        "locator" : "550:24-550:56",
                        "name" : "{http://hl7.org/fhir}MedicationRequest",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "1086",
                     "locator" : "550:63-550:97",
                     "name" : "MedicationRequestPeriod",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "asType" : "{http://hl7.org/fhir}MedicationRequest",
                        "type" : "As",
                        "operand" : {
                           "localId" : "1085",
                           "locator" : "550:87-550:96",
                           "name" : "medication",
                           "type" : "OperandRef"
                        }
                     } ]
                  }
               }, {
                  "localId" : "1093",
                  "locator" : "551:5-551:83",
                  "when" : {
                     "localId" : "1090",
                     "locator" : "551:10-551:41",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "1088",
                        "locator" : "551:10-551:19",
                        "name" : "medication",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "1089",
                        "locator" : "551:24-551:41",
                        "name" : "{http://hl7.org/fhir}MedicationDispense",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "1092",
                     "locator" : "551:48-551:83",
                     "name" : "MedicationDispensePeriod",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "asType" : "{http://hl7.org/fhir}MedicationDispense",
                        "type" : "As",
                        "operand" : {
                           "localId" : "1091",
                           "locator" : "551:73-551:82",
                           "name" : "medication",
                           "type" : "OperandRef"
                        }
                     } ]
                  }
               } ],
               "else" : {
                  "type" : "As",
                  "operand" : {
                     "localId" : "1094",
                     "locator" : "552:10-552:13",
                     "type" : "Null"
                  },
                  "asTypeSpecifier" : {
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "name" : "{urn:hl7-org:elm-types:r1}Date",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "medication",
               "operandTypeSpecifier" : {
                  "localId" : "1081",
                  "locator" : "546:14-548:3",
                  "type" : "ChoiceTypeSpecifier",
                  "choice" : [ {
                     "localId" : "1079",
                     "locator" : "546:21-546:53",
                     "name" : "{http://hl7.org/fhir}MedicationRequest",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "1080",
                     "locator" : "547:5-547:24",
                     "name" : "{http://hl7.org/fhir}MedicationDispense",
                     "type" : "NamedTypeSpecifier"
                  } ]
               }
            } ]
         }, {
            "localId" : "1122",
            "locator" : "569:1-585:3",
            "name" : "CumulativeMedicationDuration",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1122",
                  "s" : [ {
                     "value" : [ "/*\nWe can then use this function, combined with the MedicationDuration functions above\nto calculate Cumulative Medication Duration:\n\nGenerally speaking, we want to _roll out_ intervals from dispense and administration\nevents, and then collapse across that result and intervals from prescriptions.\n\nNote also that the separation of medications by type should already be done\nby this stage as well.\n\nCalculations that combine dosages from different types of medications (such as Morphine Milligram Equivalent (MME)\nor Average MME) require further consideration.\n*/\n","define function ","CumulativeMedicationDuration","(\n  ","Medications"," " ]
                  }, {
                     "r" : "1100",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1099",
                        "s" : [ {
                           "value" : [ "Choice<" ]
                        }, {
                           "r" : "1097",
                           "s" : [ {
                              "value" : [ "USCore",".","\"MedicationRequestProfile\"" ]
                           } ]
                        }, {
                           "value" : [ ",\n    " ]
                        }, {
                           "r" : "1098",
                           "s" : [ {
                              "value" : [ "\"MedicationDispense\"" ]
                           } ]
                        }, {
                           "value" : [ "\n  >" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1121",
                     "s" : [ {
                        "r" : "1121",
                        "s" : [ {
                           "value" : [ "CumulativeDuration","(" ]
                        }, {
                           "r" : "1120",
                           "s" : [ {
                              "r" : "1109",
                              "s" : [ {
                                 "value" : [ "(\n      " ]
                              }, {
                                 "r" : "1109",
                                 "s" : [ {
                                    "s" : [ {
                                       "r" : "1102",
                                       "s" : [ {
                                          "r" : "1101",
                                          "s" : [ {
                                             "s" : [ {
                                                "value" : [ "Medications" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","M" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n        " ]
                                 }, {
                                    "r" : "1105",
                                    "s" : [ {
                                       "value" : [ "where " ]
                                    }, {
                                       "r" : "1105",
                                       "s" : [ {
                                          "r" : "1103",
                                          "s" : [ {
                                             "value" : [ "M" ]
                                          } ]
                                       }, {
                                          "value" : [ " is " ]
                                       }, {
                                          "r" : "1104",
                                          "s" : [ {
                                             "value" : [ "MedicationRequest" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n        " ]
                                 }, {
                                    "r" : "1108",
                                    "s" : [ {
                                       "value" : [ "return " ]
                                    }, {
                                       "r" : "1107",
                                       "s" : [ {
                                          "value" : [ "MedicationRequestPeriod","(" ]
                                       }, {
                                          "r" : "1106",
                                          "s" : [ {
                                             "value" : [ "M" ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    )" ]
                              } ]
                           }, {
                              "value" : [ "\n      union " ]
                           }, {
                              "r" : "1119",
                              "s" : [ {
                                 "value" : [ "(\n        " ]
                              }, {
                                 "r" : "1119",
                                 "s" : [ {
                                    "value" : [ "RolloutIntervals","(\n          " ]
                                 }, {
                                    "r" : "1118",
                                    "s" : [ {
                                       "s" : [ {
                                          "r" : "1111",
                                          "s" : [ {
                                             "r" : "1110",
                                             "s" : [ {
                                                "s" : [ {
                                                   "value" : [ "Medications" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " ","M" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n            " ]
                                    }, {
                                       "r" : "1114",
                                       "s" : [ {
                                          "value" : [ "where " ]
                                       }, {
                                          "r" : "1114",
                                          "s" : [ {
                                             "r" : "1112",
                                             "s" : [ {
                                                "value" : [ "M" ]
                                             } ]
                                          }, {
                                             "value" : [ " is " ]
                                          }, {
                                             "r" : "1113",
                                             "s" : [ {
                                                "value" : [ "MedicationDispense" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n            " ]
                                    }, {
                                       "r" : "1117",
                                       "s" : [ {
                                          "value" : [ "return " ]
                                       }, {
                                          "r" : "1116",
                                          "s" : [ {
                                             "value" : [ "MedicationDispensePeriod","(" ]
                                          }, {
                                             "r" : "1115",
                                             "s" : [ {
                                                "value" : [ "M" ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n        )" ]
                                 } ]
                              }, {
                                 "value" : [ "\n      )" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1121",
               "locator" : "573:3-585:3",
               "name" : "CumulativeDuration",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "1120",
                  "locator" : "573:22-584:7",
                  "type" : "Union",
                  "operand" : [ {
                     "localId" : "1109",
                     "locator" : "573:22-577:5",
                     "type" : "Query",
                     "source" : [ {
                        "localId" : "1102",
                        "locator" : "574:7-574:19",
                        "alias" : "M",
                        "expression" : {
                           "localId" : "1101",
                           "locator" : "574:7-574:17",
                           "name" : "Medications",
                           "type" : "OperandRef"
                        }
                     } ],
                     "relationship" : [ ],
                     "where" : {
                        "localId" : "1105",
                        "locator" : "575:9-575:36",
                        "type" : "Is",
                        "operand" : {
                           "localId" : "1103",
                           "locator" : "575:15",
                           "name" : "M",
                           "type" : "AliasRef"
                        },
                        "isTypeSpecifier" : {
                           "localId" : "1104",
                           "locator" : "575:20-575:36",
                           "name" : "{http://hl7.org/fhir}MedicationRequest",
                           "type" : "NamedTypeSpecifier"
                        }
                     },
                     "return" : {
                        "localId" : "1108",
                        "locator" : "576:9-576:41",
                        "expression" : {
                           "localId" : "1107",
                           "locator" : "576:16-576:41",
                           "name" : "MedicationRequestPeriod",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "asType" : "{http://hl7.org/fhir}MedicationRequest",
                              "type" : "As",
                              "operand" : {
                                 "localId" : "1106",
                                 "locator" : "576:40",
                                 "name" : "M",
                                 "type" : "AliasRef"
                              }
                           } ]
                        }
                     }
                  }, {
                     "localId" : "1119",
                     "locator" : "578:13-584:7",
                     "name" : "RolloutIntervals",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "1118",
                        "locator" : "580:11-582:46",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "1111",
                           "locator" : "580:11-580:23",
                           "alias" : "M",
                           "expression" : {
                              "localId" : "1110",
                              "locator" : "580:11-580:21",
                              "name" : "Medications",
                              "type" : "OperandRef"
                           }
                        } ],
                        "relationship" : [ ],
                        "where" : {
                           "localId" : "1114",
                           "locator" : "581:13-581:41",
                           "type" : "Is",
                           "operand" : {
                              "localId" : "1112",
                              "locator" : "581:19",
                              "name" : "M",
                              "type" : "AliasRef"
                           },
                           "isTypeSpecifier" : {
                              "localId" : "1113",
                              "locator" : "581:24-581:41",
                              "name" : "{http://hl7.org/fhir}MedicationDispense",
                              "type" : "NamedTypeSpecifier"
                           }
                        },
                        "return" : {
                           "localId" : "1117",
                           "locator" : "582:13-582:46",
                           "expression" : {
                              "localId" : "1116",
                              "locator" : "582:20-582:46",
                              "name" : "MedicationDispensePeriod",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "asType" : "{http://hl7.org/fhir}MedicationDispense",
                                 "type" : "As",
                                 "operand" : {
                                    "localId" : "1115",
                                    "locator" : "582:45",
                                    "name" : "M",
                                    "type" : "AliasRef"
                                 }
                              } ]
                           }
                        }
                     } ]
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "Medications",
               "operandTypeSpecifier" : {
                  "localId" : "1100",
                  "locator" : "570:15-572:4",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1099",
                     "locator" : "570:20-572:3",
                     "type" : "ChoiceTypeSpecifier",
                     "choice" : [ {
                        "localId" : "1097",
                        "locator" : "570:27-570:59",
                        "name" : "{http://hl7.org/fhir}MedicationRequest",
                        "type" : "NamedTypeSpecifier"
                     }, {
                        "localId" : "1098",
                        "locator" : "571:5-571:24",
                        "name" : "{http://hl7.org/fhir}MedicationDispense",
                        "type" : "NamedTypeSpecifier"
                     } ]
                  }
               }
            } ]
         } ]
      }
   }
}" + } ] +} \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-GMTPInitialExpressions.json b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-GMTPInitialExpressions.json new file mode 100644 index 000000000..1b6e42879 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-GMTPInitialExpressions.json @@ -0,0 +1,487 @@ +{ + "resourceType": "Library", + "id": "GMTPInitialExpressions", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/cqf/us/common/Library/GMTPInitialExpressions", + "version": "0.1.0", + "name": "GMTPInitialExpressions", + "relatedArtifact": [ { + "type": "depends-on", + "display": "USCore model information", + "resource": "http://hl7.org/fhir/Library/USCore-ModelInfo" + }, { + "type": "depends-on", + "display": "FHIR model information", + "resource": "http://fhir.org/guides/cqf/common/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Library UC", + "resource": "http://fhir.org/guides/cqf/us/common/Library/USCoreCommon|0.1.0" + }, { + "type": "depends-on", + "display": "Library UCE", + "resource": "http://fhir.org/guides/cqf/us/common/Library/USCoreElements|0.1.0" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, { + "type": "depends-on", + "display": "Code system Identifier Type", + "resource": "http://terminology.hl7.org/CodeSystem/v2-0203" + } ], + "parameter": [ { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Humana ID", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Patient Name", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Date of Birth", + "use": "out", + "min": 0, + "max": "1", + "type": "date" + }, { + "name": "Phone Number", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "All ServiceRequests", + "use": "out", + "min": 0, + "max": "*", + "type": "ServiceRequest" + }, { + "name": "Most Recent ServiceRequest", + "use": "out", + "min": 0, + "max": "1", + "type": "ServiceRequest" + }, { + "name": "Requesting Provider Practitioner", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Requesting Provider", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Requesting Provider Name", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Requesting Provider Phone", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Requesting Provider NPI", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Requesting Provider Fax", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Servicing Provider", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Servicing Provider Name", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Servicing Provider Phone", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Servicing Provider NPI", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Servicing Provider Fax", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Test Coverage", + "use": "out", + "min": 0, + "max": "*", + "type": "Coverage" + }, { + "name": "Billing Provider", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Billing Provider Name", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Billing Provider Phone", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Billing Provider NPI", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Billing Provider Fax", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Date of Service", + "use": "out", + "min": 0, + "max": "1", + "type": "dateTime" + }, { + "name": "Requested Test", + "use": "out", + "min": 0, + "max": "1", + "type": "CodeableConcept" + }, { + "name": "Test ID", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Test name", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Test ICD Codes", + "use": "out", + "min": 0, + "max": "*", + "type": "Coding" + }, { + "name": "Test CPT Codes", + "use": "out", + "min": 0, + "max": "*", + "type": "Coding" + }, { + "name": "ALL ICD and CPT Test Codes", + "use": "out", + "min": 0, + "max": "*", + "type": "Coding" + }, { + "name": "Test Related Condition", + "use": "out", + "min": 0, + "max": "*", + "type": "Condition" + }, { + "name": "Diagnosis Descriptions", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Billing Provider different from Servicing Provider", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Research Subject", + "use": "out", + "min": 0, + "max": "*", + "type": "ResearchSubject" + }, { + "name": "Clinical Trial", + "use": "out", + "min": 0, + "max": "*", + "type": "ResearchStudy" + }, { + "name": "Clinical Trial Organization", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "BillingProvider is Clinical Trial Organisation", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, { + "name": "Is Research Subject", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, { + "name": "Part of clinical trial", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "All clinical Trials", + "use": "out", + "min": 0, + "max": "*", + "type": "ResearchStudy" + }, { + "name": "Clinical Trial ID", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Previous genetic testing for condition", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + } ], + "dataRequirement": [ { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "Coverage", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Coverage" ], + "mustSupport": [ "beneficiary", "beneficiary.reference", "identifier", "value", "value.value", "type", "type.coding" ] + }, { + "type": "Coverage", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Coverage" ], + "mustSupport": [ "beneficiary", "beneficiary.reference", "identifier", "value", "value.value", "type", "type.coding" ] + }, { + "type": "Coverage", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Coverage" ], + "mustSupport": [ "beneficiary", "beneficiary.reference", "identifier", "value", "value.value", "type", "type.coding" ] + }, { + "type": "Coverage", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Coverage" ], + "mustSupport": [ "beneficiary", "beneficiary.reference", "identifier", "value", "value.value", "type", "type.coding" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "ServiceRequest", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ServiceRequest" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "Coverage", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Coverage" ], + "mustSupport": [ "id" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "mustSupport": [ "id", "code", "coding", "display", "value" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "mustSupport": [ "id", "code", "coding", "display", "value" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "mustSupport": [ "id", "code", "coding", "display", "value" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "mustSupport": [ "id", "code", "coding", "display", "value" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "mustSupport": [ "id", "code", "coding", "display", "value" ] + }, { + "type": "ResearchSubject", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ResearchSubject" ], + "mustSupport": [ "individual", "individual.reference", "study", "study.reference" ] + }, { + "type": "ResearchStudy", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ResearchStudy" ], + "mustSupport": [ "id", "condition" ] + }, { + "type": "ResearchSubject", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ResearchSubject" ], + "mustSupport": [ "individual", "individual.reference", "study", "study.reference" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "mustSupport": [ "id", "code", "coding", "display", "value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value" ] + }, { + "type": "ResearchStudy", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ResearchStudy" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Condition" ], + "mustSupport": [ "id" ] + }, { + "type": "ServiceRequest", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ServiceRequest" ], + "mustSupport": [ "occurrence", "id", "reasonReference", "id.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ], + "mustSupport": [ "id", "id.value", "name", "family", "family.value", "telecom", "identifier", "system", "system.value", "value", "value.value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ], + "mustSupport": [ "id", "id.value", "system", "system.value", "value", "value.value" ] + }, { + "type": "ResearchSubject", + "profile": [ "http://hl7.org/fhir/StructureDefinition/ResearchSubject" ], + "mustSupport": [ "individual", "individual.reference", "study", "study.reference" ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "library GMTPInitialExpressions version '0.1.0'

using USCore version '3.1.1'
using FHIR version '4.0.1'

include FHIRHelpers version '4.1.000'
include USCoreCommon version '0.1.0' called UC
include USCoreElements version '0.1.0' called UCE

codesystem "LOINC": 'http://loinc.org'
codesystem "Identifier Type": 'http://terminology.hl7.org/CodeSystem/v2-0203'
code "Member Number": 'MB' from "Identifier Type"


context Patient

define "Humana ID": // Similar to Member ID from MBODA Initial expressions?
  singleton from
    (
      (
        (
          ([FHIR.Coverage] C 
              where EndsWith(C.beneficiary.reference, Patient.id))
          .identifier) I
        return {value: I.value.value, type: I.type.coding.code}
      ) valuesByTypes
    where "Member Number".code in valuesByTypes.type
    return valuesByTypes.value
    )

define "Patient Name":
  UCE."Name - First Middle(s) Last"

define "Date of Birth":
  Patient.birthDate

define "Phone Number":
  UC.Mobile(Patient.telecom).value

// TODO: Error: Could not resolve data provider for package 'java.util'.
/*
define "Address":
   (singleton from Patient.address).line
*/

define "Requesting Provider Practitioner"://assuming the requester is a practitioner
  [PractitionerProfile] P
    where EndsWith("Most Recent ServiceRequest".requester.reference.value, P.id)

/*//if the requester is an Organization:
define "Requesting Provider Organization":
  [OrganizationProfile] O
    where EndsWith("Most Recent ServiceRequest".requester.reference.value, O.id)
 */
   
define "Requesting Provider":
   "Requesting Provider Practitioner"
  
  
define "Requesting Provider Name":
  "Requesting Provider".name.family 

define "Requesting Provider Phone":
  UC.Mobile("Requesting Provider".telecom).value
/*
define "Requesting Provider Address":
  (singleton from "Requesting Provider".address).line
*/
define "Requesting Provider NPI":
  "Requesting Provider".identifier I 
  where I.system = 'http://hl7.org/fhir/sid/us-npi'
  return I.value

define "Requesting Provider Fax":
  "Requesting Provider".telecom T
  where T.system = 'fax'
  return T.value


define "Servicing Provider"://assuming the servicing provider is a lab - (molecular/genetic testing)
   singleton from ([OrganizationProfile] O
  where EndsWith(First("Most Recent ServiceRequest".performer.reference.value), O.id))

define "Servicing Provider Name":
    "Servicing Provider".name

define "Servicing Provider Phone":
  UC.Mobile("Servicing Provider".telecom).value

// TODO: Error: Could not resolve data provider for package 'java.util'.
/*
define "Servicing Provider Address":
  (singleton from "Servicing Provider".address).line
*/
define "Servicing Provider NPI":
  "Servicing Provider".identifier I 
  where I.system = 'http://hl7.org/fhir/sid/us-npi'
  return I.value

define "Servicing Provider Fax":
  "Servicing Provider".telecom T
  where T.system = 'fax'
  return T.value

define "Test Coverage":
[FHIR.Coverage] C
with  "Most Recent ServiceRequest" SR such that  EndsWith(First(SR.insurance.reference), C.id)


define "Billing Provider":
 singleton from([OrganizationProfile] O
  where EndsWith(First("Test Coverage".payor.reference.value), O.id))

define "Billing Provider Name":
  "Billing Provider".name

define "Billing Provider Phone":
  UC.Mobile("Billing Provider".telecom).value

// TODO: Error: Could not resolve data provider for package 'java.util'.
/*
define "Billing Provider Address":
  (singleton from "Billing Provider".address).line
*/
define "Billing Provider NPI":
  "Billing Provider".identifier I 
  where I.system = 'http://hl7.org/fhir/sid/us-npi'
  return I.value

define "Billing Provider Fax":
  "Billing Provider".telecom T
  where T.system = 'fax'
  return T.value

define "All ServiceRequests":
  [FHIR.ServiceRequest]

define "Most Recent ServiceRequest":
  UC.MostRecentSR("All ServiceRequests")

define "Date of Service":
  "Most Recent ServiceRequest".occurrence.value

define "Requested Test":
  "Most Recent ServiceRequest" SR
  return SR.code

define "Test ID":
  "Requested Test".coding.code.value 

define "Test name":
   "Requested Test".coding.display.value 

define "ALL ICD and CPT Test Codes":
   "Test ICD Codes" union "Test CPT Codes" as List<FHIR.Coding>

define "Test ICD Codes":
 "Requested Test".coding C
  where C.system.value =  'http://hl7.org/fhir/sid/icd-10-cm'
  return C
  
define "Test CPT Codes":
  "Requested Test".coding C
  where C.system.value =  'http://www.ama-assn.org/go/cpt'
  return C

define "Test Related Condition":
  [FHIR.Condition] C
  where EndsWith(First("Most Recent ServiceRequest".reasonReference.reference.value), C.id)
  //.reasonReference changed to .reason in FHIR R5

define "Diagnosis Descriptions":
  "Test Related Condition".code.coding.display.value

define "Billing Provider different from Servicing Provider":
  if "Billing Provider".id != "Servicing Provider".id then
  'Yes'
  else 
  'No'

define "Clinical Trial Organization":
  First([OrganizationProfile] O
 with "Clinical Trial"  T such that EndsWith(T.sponsor.reference, O.id))  //in FHIR R5 T.associatedParty instead of T.sponsor 

define "BillingProvider is Clinical Trial Organisation":
  "Billing Provider" = "Clinical Trial Organization"

//TODO does not get populated properly
define "Part of clinical trial":
 if "Is Research Subject" and "BillingProvider is Clinical Trial Organisation" then
 'Yes'
 else
 'No'

define "Is Research Subject":
  exists("Research Subject")

define "Research Subject":
     [FHIR.ResearchSubject] R
     where  EndsWith(R.individual.reference, Patient.id)//ResearchSubject.individual is from FHIR version v4.0.1 and has been replaced by R.subject in FHIR R5

define "All clinical Trials":
[FHIR.ResearchStudy] R 

define "Clinical Trial":
  [FHIR.ResearchStudy] R 
  with "Research Subject" S such that EndsWith(S.study.reference, R.id)
  with  "Test Related Condition" C such that C.code in R.condition 

define "Clinical Trial ID":
  "Clinical Trial".identifier C
  where C.system = 'https://clinicaltrials.gov'
  return C.value.value


define function "GetServiceRequestReasonCondition"(S ServiceRequest):
  [FHIR.Condition] C
  with  "Most Recent ServiceRequest" SR such that  EndsWith(First(SR.insurance.reference), C.id)
  return C


define "Previous genetic testing for condition":
   from "All ServiceRequests" S,
   "Most Recent ServiceRequest" SR 
   where S.occurrence before SR.occurrence
   and S.id != SR.id
   and S.reasonReference = SR.reasonReference
  return S.id.value
         

//define "Family history of genetic testing"
//too general to prefill?

//define "Patient history"
//too general to prefill?


" + }, { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1">
   <annotation translatorVersion="2.7.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="403">
         <a:s>library GMTPInitialExpressions version '0.1.0'</a:s>
      </a:s>
   </annotation>
   <identifier id="GMTPInitialExpressions" system="http://fhir.org/guides/cqf/us/common" version="0.1.0"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="3:1-3:28" localIdentifier="USCore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="1">
               <a:s>using </a:s>
               <a:s>
                  <a:s>USCore</a:s>
               </a:s>
               <a:s> version '3.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="2" locator="4:1-4:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1">
         <annotation xsi:type="a:Annotation">
            <a:s r="2">
               <a:s>using </a:s>
               <a:s>
                  <a:s>FHIR</a:s>
               </a:s>
               <a:s> version '4.0.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="3" locator="6:1-6:37" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/cqf/us/common/FHIRHelpers" version="4.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="3">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.1.000'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="4" locator="7:1-7:46" localIdentifier="UC" path="http://fhir.org/guides/cqf/us/common/USCoreCommon" version="0.1.0">
         <annotation xsi:type="a:Annotation">
            <a:s r="4">
               <a:s>include </a:s>
               <a:s>
                  <a:s>USCoreCommon</a:s>
               </a:s>
               <a:s> version '0.1.0' called UC</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="5" locator="8:1-8:49" localIdentifier="UCE" path="http://fhir.org/guides/cqf/us/common/USCoreElements" version="0.1.0">
         <annotation xsi:type="a:Annotation">
            <a:s r="5">
               <a:s>include </a:s>
               <a:s>
                  <a:s>USCoreElements</a:s>
               </a:s>
               <a:s> version '0.1.0' called UCE</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <codeSystems>
      <def localId="6" locator="10:1-10:38" name="LOINC" id="http://loinc.org" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="6">
               <a:s>codesystem &quot;LOINC&quot;: 'http://loinc.org'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="7" locator="11:1-11:77" name="Identifier Type" id="http://terminology.hl7.org/CodeSystem/v2-0203" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="7">
               <a:s>codesystem &quot;Identifier Type&quot;: 'http://terminology.hl7.org/CodeSystem/v2-0203'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <codes>
      <def localId="9" locator="12:1-12:49" name="Member Number" id="MB" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="9">
               <a:s>code &quot;Member Number&quot;: 'MB' from </a:s>
               <a:s r="8">
                  <a:s>&quot;Identifier Type&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="8" locator="12:33-12:49" name="Identifier Type"/>
      </def>
   </codes>
   <contexts>
      <def locator="15:1-15:15" name="Patient"/>
   </contexts>
   <statements>
      <def locator="15:1-15:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="15:1-15:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="42" locator="17:1-29:5" name="Humana ID" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="42">
               <a:s>define &quot;Humana ID&quot;: // Similar to Member ID from MBODA Initial expressions?
  </a:s>
               <a:s r="41">
                  <a:s>singleton from
    </a:s>
                  <a:s r="40">
                     <a:s>(
      </a:s>
                     <a:s r="40">
                        <a:s>
                           <a:s r="31">
                              <a:s r="30">
                                 <a:s>(
        </a:s>
                                 <a:s r="30">
                                    <a:s>
                                       <a:s r="20">
                                          <a:s r="19">
                                             <a:s>(
          </a:s>
                                             <a:s r="19">
                                                <a:s r="18">
                                                   <a:s>(</a:s>
                                                   <a:s r="18">
                                                      <a:s>
                                                         <a:s r="11">
                                                            <a:s r="10">
                                                               <a:s r="10">
                                                                  <a:s>[FHIR.Coverage]</a:s>
                                                               </a:s>
                                                            </a:s>
                                                            <a:s> C</a:s>
                                                         </a:s>
                                                      </a:s>
                                                      <a:s> 
              </a:s>
                                                      <a:s r="17">
                                                         <a:s>where </a:s>
                                                         <a:s r="17">
                                                            <a:s>EndsWith(</a:s>
                                                            <a:s r="14">
                                                               <a:s r="13">
                                                                  <a:s r="12">
                                                                     <a:s>C</a:s>
                                                                  </a:s>
                                                                  <a:s>.</a:s>
                                                                  <a:s r="13">
                                                                     <a:s>beneficiary</a:s>
                                                                  </a:s>
                                                               </a:s>
                                                               <a:s>.</a:s>
                                                               <a:s r="14">
                                                                  <a:s>reference</a:s>
                                                               </a:s>
                                                            </a:s>
                                                            <a:s>, </a:s>
                                                            <a:s r="16">
                                                               <a:s r="15">
                                                                  <a:s>Patient</a:s>
                                                               </a:s>
                                                               <a:s>.</a:s>
                                                               <a:s r="16">
                                                                  <a:s>id</a:s>
                                                               </a:s>
                                                            </a:s>
                                                            <a:s>)</a:s>
                                                         </a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                                <a:s>
          .</a:s>
                                                <a:s r="19">
                                                   <a:s>identifier</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                          <a:s> I</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="29">
                                       <a:s>return </a:s>
                                       <a:s r="28">
                                          <a:s>{</a:s>
                                          <a:s>
                                             <a:s>value: </a:s>
                                             <a:s r="23">
                                                <a:s r="22">
                                                   <a:s r="21">
                                                      <a:s>I</a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="22">
                                                      <a:s>value</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="23">
                                                   <a:s>value</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>, </a:s>
                                          <a:s>
                                             <a:s>type: </a:s>
                                             <a:s r="27">
                                                <a:s r="26">
                                                   <a:s r="25">
                                                      <a:s r="24">
                                                         <a:s>I</a:s>
                                                      </a:s>
                                                      <a:s>.</a:s>
                                                      <a:s r="25">
                                                         <a:s>type</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="26">
                                                      <a:s>coding</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="27">
                                                   <a:s>code</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>}</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
      )</a:s>
                              </a:s>
                              <a:s> valuesByTypes</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    </a:s>
                        <a:s r="36">
                           <a:s>where </a:s>
                           <a:s r="36">
                              <a:s r="33">
                                 <a:s r="32">
                                    <a:s>&quot;Member Number&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="33">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> in </a:s>
                              <a:s r="35">
                                 <a:s r="34">
                                    <a:s>valuesByTypes</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="35">
                                    <a:s>type</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    </a:s>
                        <a:s r="39">
                           <a:s>return </a:s>
                           <a:s r="38">
                              <a:s r="37">
                                 <a:s>valuesByTypes</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="38">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="41" locator="18:3-29:5" xsi:type="SingletonFrom">
            <operand localId="40" locator="19:5-29:5" xsi:type="Query">
               <source localId="31" locator="20:7-26:21" alias="valuesByTypes">
                  <expression localId="30" locator="20:7-26:7" xsi:type="Query">
                     <source localId="20" locator="21:9-24:24" alias="I">
                        <expression localId="19" locator="21:9-24:22" xsi:type="Flatten">
                           <operand xsi:type="Query">
                              <source alias="$this">
                                 <expression localId="18" locator="22:11-23:66" xsi:type="Query">
                                    <source localId="11" locator="22:12-22:28" alias="C">
                                       <expression localId="10" locator="22:12-22:26" dataType="fhir:Coverage" templateId="http://hl7.org/fhir/StructureDefinition/Coverage" xsi:type="Retrieve"/>
                                    </source>
                                    <where localId="17" locator="23:15-23:65" xsi:type="EndsWith">
                                       <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand localId="14" locator="23:30-23:52" path="reference" xsi:type="Property">
                                             <source localId="13" locator="23:30-23:42" path="beneficiary" scope="C" xsi:type="Property"/>
                                          </operand>
                                       </operand>
                                       <operand localId="16" locator="23:55-23:64" path="value" xsi:type="Property">
                                          <source path="id" xsi:type="Property">
                                             <source localId="15" locator="23:55-23:61" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                    </where>
                                 </expression>
                              </source>
                              <where xsi:type="Not">
                                 <operand xsi:type="IsNull">
                                    <operand path="identifier" xsi:type="Property">
                                       <source name="$this" xsi:type="AliasRef"/>
                                    </operand>
                                 </operand>
                              </where>
                              <return distinct="false">
                                 <expression path="identifier" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </expression>
                              </return>
                           </operand>
                        </expression>
                     </source>
                     <return localId="29" locator="25:9-25:63">
                        <expression localId="28" locator="25:16-25:63" xsi:type="Tuple">
                           <element name="value">
                              <value localId="23" locator="25:24-25:36" path="value" xsi:type="Property">
                                 <source localId="22" locator="25:24-25:30" path="value" scope="I" xsi:type="Property"/>
                              </value>
                           </element>
                           <element name="type">
                              <value localId="27" locator="25:45-25:62" xsi:type="Query">
                                 <source alias="$this">
                                    <expression localId="26" locator="25:45-25:57" path="coding" xsi:type="Property">
                                       <source localId="25" locator="25:45-25:50" path="type" scope="I" xsi:type="Property"/>
                                    </expression>
                                 </source>
                                 <where xsi:type="Not">
                                    <operand xsi:type="IsNull">
                                       <operand path="code" xsi:type="Property">
                                          <source name="$this" xsi:type="AliasRef"/>
                                       </operand>
                                    </operand>
                                 </where>
                                 <return distinct="false">
                                    <expression path="code" xsi:type="Property">
                                       <source name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </value>
                           </element>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="36" locator="27:5-27:52" xsi:type="In">
                  <operand localId="33" locator="27:11-27:30" path="code" xsi:type="Property">
                     <source localId="32" locator="27:11-27:25" name="Member Number" xsi:type="CodeRef"/>
                  </operand>
                  <operand xsi:type="Query">
                     <source alias="X">
                        <expression localId="35" locator="27:35-27:52" path="type" scope="valuesByTypes" xsi:type="Property"/>
                     </source>
                     <return distinct="false">
                        <expression name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="X" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
               </where>
               <return localId="39" locator="28:5-28:30">
                  <expression localId="38" locator="28:12-28:30" path="value" scope="valuesByTypes" xsi:type="Property"/>
               </return>
            </operand>
         </expression>
      </def>
      <def localId="45" locator="31:1-32:35" name="Patient Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="45">
               <a:s>define &quot;Patient Name&quot;:
  </a:s>
               <a:s r="44">
                  <a:s r="43">
                     <a:s>UCE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="44">
                     <a:s>&quot;Name - First Middle(s) Last&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="44" locator="32:3-32:35" name="Name - First Middle(s) Last" libraryName="UCE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="48" locator="34:1-35:19" name="Date of Birth" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="48">
               <a:s>define &quot;Date of Birth&quot;:
  </a:s>
               <a:s r="47">
                  <a:s r="46">
                     <a:s>Patient</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="47">
                     <a:s>birthDate</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="47" locator="35:3-35:19" path="value" xsi:type="Property">
            <source path="birthDate" xsi:type="Property">
               <source localId="46" locator="35:3-35:9" name="Patient" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="54" locator="37:1-38:34" name="Phone Number" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="54">
               <a:s>define &quot;Phone Number&quot;:
  </a:s>
               <a:s r="53">
                  <a:s r="52">
                     <a:s r="49">
                        <a:s>UC</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="52">
                        <a:s>Mobile(</a:s>
                        <a:s r="51">
                           <a:s r="50">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="51">
                              <a:s>telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="53">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="53" locator="38:3-38:34" path="value" xsi:type="Property">
            <source path="value" xsi:type="Property">
               <source localId="52" locator="38:3-38:28" name="Mobile" libraryName="UC" xsi:type="FunctionRef">
                  <operand localId="51" locator="38:13-38:27" path="telecom" xsi:type="Property">
                     <source localId="50" locator="38:13-38:19" name="Patient" xsi:type="ExpressionRef"/>
                  </operand>
               </source>
            </source>
         </expression>
      </def>
      <def localId="59" locator="135:1-136:23" name="All ServiceRequests" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="59">
               <a:s>define &quot;All ServiceRequests&quot;:
  </a:s>
               <a:s r="58">
                  <a:s>[FHIR.ServiceRequest]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="58" locator="136:3-136:23" dataType="fhir:ServiceRequest" templateId="http://hl7.org/fhir/StructureDefinition/ServiceRequest" xsi:type="Retrieve"/>
      </def>
      <def localId="62" locator="138:1-139:40" name="Most Recent ServiceRequest" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="62">
               <a:s>define &quot;Most Recent ServiceRequest&quot;:
  </a:s>
               <a:s r="61">
                  <a:s r="57">
                     <a:s>UC</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="61">
                     <a:s>MostRecentSR(</a:s>
                     <a:s r="60">
                        <a:s>&quot;All ServiceRequests&quot;</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="61" locator="139:3-139:40" name="MostRecentSR" libraryName="UC" xsi:type="FunctionRef">
            <operand localId="60" locator="139:19-139:39" name="All ServiceRequests" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="71" locator="46:1-48:80" name="Requesting Provider Practitioner" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="71">
               <a:s>// TODO: Error: Could not resolve data provider for package 'java.util'.
/*
define &quot;Address&quot;:
   (singleton from Patient.address).line
*/
define &quot;Requesting Provider Practitioner&quot;://assuming the requester is a practitioner
  </a:s>
               <a:s r="70">
                  <a:s>
                     <a:s r="56">
                        <a:s r="55">
                           <a:s r="55">
                              <a:s>[PractitionerProfile]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> P</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="69">
                     <a:s>where </a:s>
                     <a:s r="69">
                        <a:s>EndsWith(</a:s>
                        <a:s r="66">
                           <a:s r="65">
                              <a:s r="64">
                                 <a:s r="63">
                                    <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="64">
                                    <a:s>requester</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="65">
                                 <a:s>reference</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="66">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="68">
                           <a:s r="67">
                              <a:s>P</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="68">
                              <a:s>id</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="70" locator="47:3-48:80" xsi:type="Query">
            <source localId="56" locator="47:3-47:25" alias="P">
               <expression localId="55" locator="47:3-47:23" dataType="fhir:Practitioner" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" xsi:type="Retrieve"/>
            </source>
            <where localId="69" locator="48:5-48:80" xsi:type="EndsWith">
               <operand localId="66" locator="48:20-48:73" path="value" xsi:type="Property">
                  <source localId="65" locator="48:20-48:67" path="reference" xsi:type="Property">
                     <source localId="64" locator="48:20-48:57" path="requester" xsi:type="Property">
                        <source localId="63" locator="48:20-48:47" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
                     </source>
                  </source>
               </operand>
               <operand localId="68" locator="48:76-48:79" path="value" xsi:type="Property">
                  <source path="id" scope="P" xsi:type="Property"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="73" locator="56:1-57:37" name="Requesting Provider" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="73">
               <a:s>/*//if the requester is an Organization:
define &quot;Requesting Provider Organization&quot;:
  [OrganizationProfile] O
    where EndsWith(&quot;Most Recent ServiceRequest&quot;.requester.reference.value, O.id)
 */
define &quot;Requesting Provider&quot;:
   </a:s>
               <a:s r="72">
                  <a:s>&quot;Requesting Provider Practitioner&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="72" locator="57:4-57:37" name="Requesting Provider Practitioner" xsi:type="ExpressionRef"/>
      </def>
      <def localId="77" locator="60:1-61:35" name="Requesting Provider Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="77">
               <a:s>define &quot;Requesting Provider Name&quot;:
  </a:s>
               <a:s r="76">
                  <a:s r="75">
                     <a:s r="74">
                        <a:s>&quot;Requesting Provider&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="75">
                        <a:s>name</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="76">
                     <a:s>family</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="76" locator="61:3-61:35" xsi:type="Query">
            <source alias="$this">
               <expression localId="75" locator="61:3-61:28" xsi:type="Flatten">
                  <operand xsi:type="Query">
                     <source alias="$this">
                        <expression localId="74" locator="61:3-61:23" name="Requesting Provider" xsi:type="ExpressionRef"/>
                     </source>
                     <where xsi:type="Not">
                        <operand xsi:type="IsNull">
                           <operand path="name" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </operand>
                        </operand>
                     </where>
                     <return distinct="false">
                        <expression path="name" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand path="value" xsi:type="Property">
                     <source path="family" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </source>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression path="value" xsi:type="Property">
                  <source path="family" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </source>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="83" locator="63:1-64:48" name="Requesting Provider Phone" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="83">
               <a:s>define &quot;Requesting Provider Phone&quot;:
  </a:s>
               <a:s r="82">
                  <a:s r="81">
                     <a:s r="78">
                        <a:s>UC</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="81">
                        <a:s>Mobile(</a:s>
                        <a:s r="80">
                           <a:s r="79">
                              <a:s>&quot;Requesting Provider&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="80">
                              <a:s>telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="82">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="82" locator="64:3-64:48" path="value" xsi:type="Property">
            <source path="value" xsi:type="Property">
               <source localId="81" locator="64:3-64:42" name="Mobile" libraryName="UC" xsi:type="FunctionRef">
                  <operand localId="80" locator="64:13-64:41" xsi:type="Flatten">
                     <operand xsi:type="Query">
                        <source alias="$this">
                           <expression localId="79" locator="64:13-64:33" name="Requesting Provider" xsi:type="ExpressionRef"/>
                        </source>
                        <where xsi:type="Not">
                           <operand xsi:type="IsNull">
                              <operand path="telecom" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </operand>
                           </operand>
                        </where>
                        <return distinct="false">
                           <expression path="telecom" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </expression>
                        </return>
                     </operand>
                  </operand>
               </source>
            </source>
         </expression>
      </def>
      <def localId="94" locator="69:1-72:16" name="Requesting Provider NPI" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="94">
               <a:s>/*
define &quot;Requesting Provider Address&quot;:
  (singleton from &quot;Requesting Provider&quot;.address).line
*/
define &quot;Requesting Provider NPI&quot;:
  </a:s>
               <a:s r="93">
                  <a:s>
                     <a:s r="85">
                        <a:s r="84">
                           <a:s>
                              <a:s>&quot;Requesting Provider&quot;.identifier</a:s>
                           </a:s>
                        </a:s>
                        <a:s> I</a:s>
                     </a:s>
                  </a:s>
                  <a:s> 
  </a:s>
                  <a:s r="89">
                     <a:s>where </a:s>
                     <a:s r="89">
                        <a:s r="87">
                           <a:s r="86">
                              <a:s>I</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="87">
                              <a:s>system</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="88">
                           <a:s>'http://hl7.org/fhir/sid/us-npi'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="92">
                     <a:s>return </a:s>
                     <a:s r="91">
                        <a:s r="90">
                           <a:s>I</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="91">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="93" locator="70:3-72:16" xsi:type="Query">
            <source localId="85" locator="70:3-70:36" alias="I">
               <expression localId="84" locator="70:3-70:34" xsi:type="Flatten">
                  <operand xsi:type="Query">
                     <source alias="$this">
                        <expression name="Requesting Provider" xsi:type="ExpressionRef"/>
                     </source>
                     <where xsi:type="Not">
                        <operand xsi:type="IsNull">
                           <operand path="identifier" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </operand>
                        </operand>
                     </where>
                     <return distinct="false">
                        <expression path="identifier" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
               </expression>
            </source>
            <where localId="89" locator="71:3-71:51" xsi:type="Equal">
               <operand localId="87" locator="71:9-71:16" path="value" xsi:type="Property">
                  <source path="system" scope="I" xsi:type="Property"/>
               </operand>
               <operand localId="88" locator="71:20-71:51" valueType="t:String" value="http://hl7.org/fhir/sid/us-npi" xsi:type="Literal"/>
            </where>
            <return localId="92" locator="72:3-72:16">
               <expression localId="91" locator="72:10-72:16" path="value" xsi:type="Property">
                  <source path="value" scope="I" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="105" locator="74:1-77:16" name="Requesting Provider Fax" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="105">
               <a:s>define &quot;Requesting Provider Fax&quot;:
  </a:s>
               <a:s r="104">
                  <a:s>
                     <a:s r="96">
                        <a:s r="95">
                           <a:s>
                              <a:s>&quot;Requesting Provider&quot;.telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s> T</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="100">
                     <a:s>where </a:s>
                     <a:s r="100">
                        <a:s r="98">
                           <a:s r="97">
                              <a:s>T</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="98">
                              <a:s>system</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="99">
                           <a:s>'fax'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="103">
                     <a:s>return </a:s>
                     <a:s r="102">
                        <a:s r="101">
                           <a:s>T</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="102">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="104" locator="75:3-77:16" xsi:type="Query">
            <source localId="96" locator="75:3-75:33" alias="T">
               <expression localId="95" locator="75:3-75:31" xsi:type="Flatten">
                  <operand xsi:type="Query">
                     <source alias="$this">
                        <expression name="Requesting Provider" xsi:type="ExpressionRef"/>
                     </source>
                     <where xsi:type="Not">
                        <operand xsi:type="IsNull">
                           <operand path="telecom" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </operand>
                        </operand>
                     </where>
                     <return distinct="false">
                        <expression path="telecom" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
               </expression>
            </source>
            <where localId="100" locator="76:3-76:24" xsi:type="Equal">
               <operand localId="98" locator="76:9-76:16" path="value" xsi:type="Property">
                  <source path="system" scope="T" xsi:type="Property"/>
               </operand>
               <operand localId="99" locator="76:20-76:24" valueType="t:String" value="fax" xsi:type="Literal"/>
            </where>
            <return localId="103" locator="77:3-77:16">
               <expression localId="102" locator="77:10-77:16" path="value" xsi:type="Property">
                  <source path="value" scope="T" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="118" locator="80:1-82:86" name="Servicing Provider" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="118">
               <a:s>define &quot;Servicing Provider&quot;://assuming the servicing provider is a lab - (molecular/genetic testing)
   </a:s>
               <a:s r="117">
                  <a:s>singleton from </a:s>
                  <a:s r="116">
                     <a:s>(</a:s>
                     <a:s r="116">
                        <a:s>
                           <a:s r="107">
                              <a:s r="106">
                                 <a:s r="106">
                                    <a:s>[OrganizationProfile]</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  </a:s>
                        <a:s r="115">
                           <a:s>where </a:s>
                           <a:s r="115">
                              <a:s>EndsWith(</a:s>
                              <a:s r="112">
                                 <a:s>First(</a:s>
                                 <a:s r="111">
                                    <a:s r="110">
                                       <a:s r="109">
                                          <a:s r="108">
                                             <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="109">
                                             <a:s>performer</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="110">
                                          <a:s>reference</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="111">
                                       <a:s>value</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="114">
                                 <a:s r="113">
                                    <a:s>O</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="114">
                                    <a:s>id</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="117" locator="81:4-82:86" xsi:type="SingletonFrom">
            <operand localId="116" locator="81:19-82:86" xsi:type="Query">
               <source localId="107" locator="81:20-81:42" alias="O">
                  <expression localId="106" locator="81:20-81:40" dataType="fhir:Organization" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" xsi:type="Retrieve"/>
               </source>
               <where localId="115" locator="82:3-82:85" xsi:type="EndsWith">
                  <operand localId="112" locator="82:18-82:78" xsi:type="First">
                     <source localId="111" locator="82:24-82:77" xsi:type="Query">
                        <source alias="$this">
                           <expression localId="110" locator="82:24-82:71" xsi:type="Query">
                              <source alias="$this">
                                 <expression localId="109" locator="82:24-82:61" path="performer" xsi:type="Property">
                                    <source localId="108" locator="82:24-82:51" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
                                 </expression>
                              </source>
                              <where xsi:type="Not">
                                 <operand xsi:type="IsNull">
                                    <operand path="reference" xsi:type="Property">
                                       <source name="$this" xsi:type="AliasRef"/>
                                    </operand>
                                 </operand>
                              </where>
                              <return distinct="false">
                                 <expression path="reference" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </expression>
                              </return>
                           </expression>
                        </source>
                        <where xsi:type="Not">
                           <operand xsi:type="IsNull">
                              <operand path="value" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </operand>
                           </operand>
                        </where>
                        <return distinct="false">
                           <expression path="value" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </expression>
                        </return>
                     </source>
                  </operand>
                  <operand localId="114" locator="82:81-82:84" path="value" xsi:type="Property">
                     <source path="id" scope="O" xsi:type="Property"/>
                  </operand>
               </where>
            </operand>
         </expression>
      </def>
      <def localId="121" locator="84:1-85:29" name="Servicing Provider Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="121">
               <a:s>define &quot;Servicing Provider Name&quot;:
    </a:s>
               <a:s r="120">
                  <a:s r="119">
                     <a:s>&quot;Servicing Provider&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="120">
                     <a:s>name</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="120" locator="85:5-85:29" path="value" xsi:type="Property">
            <source path="name" xsi:type="Property">
               <source localId="119" locator="85:5-85:24" name="Servicing Provider" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="127" locator="87:1-88:47" name="Servicing Provider Phone" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="127">
               <a:s>define &quot;Servicing Provider Phone&quot;:
  </a:s>
               <a:s r="126">
                  <a:s r="125">
                     <a:s r="122">
                        <a:s>UC</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="125">
                        <a:s>Mobile(</a:s>
                        <a:s r="124">
                           <a:s r="123">
                              <a:s>&quot;Servicing Provider&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="124">
                              <a:s>telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="126">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="126" locator="88:3-88:47" path="value" xsi:type="Property">
            <source path="value" xsi:type="Property">
               <source localId="125" locator="88:3-88:41" name="Mobile" libraryName="UC" xsi:type="FunctionRef">
                  <operand localId="124" locator="88:13-88:40" path="telecom" xsi:type="Property">
                     <source localId="123" locator="88:13-88:32" name="Servicing Provider" xsi:type="ExpressionRef"/>
                  </operand>
               </source>
            </source>
         </expression>
      </def>
      <def localId="138" locator="95:1-98:16" name="Servicing Provider NPI" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="138">
               <a:s>// TODO: Error: Could not resolve data provider for package 'java.util'.
/*
define &quot;Servicing Provider Address&quot;:
  (singleton from &quot;Servicing Provider&quot;.address).line
*/
define &quot;Servicing Provider NPI&quot;:
  </a:s>
               <a:s r="137">
                  <a:s>
                     <a:s r="129">
                        <a:s r="128">
                           <a:s>
                              <a:s>&quot;Servicing Provider&quot;.identifier</a:s>
                           </a:s>
                        </a:s>
                        <a:s> I</a:s>
                     </a:s>
                  </a:s>
                  <a:s> 
  </a:s>
                  <a:s r="133">
                     <a:s>where </a:s>
                     <a:s r="133">
                        <a:s r="131">
                           <a:s r="130">
                              <a:s>I</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="131">
                              <a:s>system</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="132">
                           <a:s>'http://hl7.org/fhir/sid/us-npi'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="136">
                     <a:s>return </a:s>
                     <a:s r="135">
                        <a:s r="134">
                           <a:s>I</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="135">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="137" locator="96:3-98:16" xsi:type="Query">
            <source localId="129" locator="96:3-96:35" alias="I">
               <expression localId="128" locator="96:3-96:33" path="identifier" xsi:type="Property">
                  <source name="Servicing Provider" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where localId="133" locator="97:3-97:51" xsi:type="Equal">
               <operand localId="131" locator="97:9-97:16" path="value" xsi:type="Property">
                  <source path="system" scope="I" xsi:type="Property"/>
               </operand>
               <operand localId="132" locator="97:20-97:51" valueType="t:String" value="http://hl7.org/fhir/sid/us-npi" xsi:type="Literal"/>
            </where>
            <return localId="136" locator="98:3-98:16">
               <expression localId="135" locator="98:10-98:16" path="value" xsi:type="Property">
                  <source path="value" scope="I" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="149" locator="100:1-103:16" name="Servicing Provider Fax" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="149">
               <a:s>define &quot;Servicing Provider Fax&quot;:
  </a:s>
               <a:s r="148">
                  <a:s>
                     <a:s r="140">
                        <a:s r="139">
                           <a:s>
                              <a:s>&quot;Servicing Provider&quot;.telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s> T</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="144">
                     <a:s>where </a:s>
                     <a:s r="144">
                        <a:s r="142">
                           <a:s r="141">
                              <a:s>T</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="142">
                              <a:s>system</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="143">
                           <a:s>'fax'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="147">
                     <a:s>return </a:s>
                     <a:s r="146">
                        <a:s r="145">
                           <a:s>T</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="146">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="148" locator="101:3-103:16" xsi:type="Query">
            <source localId="140" locator="101:3-101:32" alias="T">
               <expression localId="139" locator="101:3-101:30" path="telecom" xsi:type="Property">
                  <source name="Servicing Provider" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where localId="144" locator="102:3-102:24" xsi:type="Equal">
               <operand localId="142" locator="102:9-102:16" path="value" xsi:type="Property">
                  <source path="system" scope="T" xsi:type="Property"/>
               </operand>
               <operand localId="143" locator="102:20-102:24" valueType="t:String" value="fax" xsi:type="Literal"/>
            </where>
            <return localId="147" locator="103:3-103:16">
               <expression localId="146" locator="103:10-103:16" path="value" xsi:type="Property">
                  <source path="value" scope="T" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="163" locator="105:1-107:94" name="Test Coverage" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="163">
               <a:s>define &quot;Test Coverage&quot;:
</a:s>
               <a:s r="162">
                  <a:s>
                     <a:s r="151">
                        <a:s r="150">
                           <a:s r="150">
                              <a:s>[FHIR.Coverage]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
</a:s>
                  <a:s r="161">
                     <a:s>with  </a:s>
                     <a:s r="153">
                        <a:s r="152">
                           <a:s>
                              <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> SR</a:s>
                     </a:s>
                     <a:s> such that  </a:s>
                     <a:s r="160">
                        <a:s>EndsWith(</a:s>
                        <a:s r="157">
                           <a:s>First(</a:s>
                           <a:s r="156">
                              <a:s r="155">
                                 <a:s r="154">
                                    <a:s>SR</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="155">
                                    <a:s>insurance</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="156">
                                 <a:s>reference</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="159">
                           <a:s r="158">
                              <a:s>C</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="159">
                              <a:s>id</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="162" locator="106:1-107:94" xsi:type="Query">
            <source localId="151" locator="106:1-106:17" alias="C">
               <expression localId="150" locator="106:1-106:15" dataType="fhir:Coverage" templateId="http://hl7.org/fhir/StructureDefinition/Coverage" xsi:type="Retrieve"/>
            </source>
            <relationship localId="161" locator="107:1-107:94" alias="SR" xsi:type="With">
               <expression localId="152" locator="107:7-107:34" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
               <suchThat localId="160" locator="107:50-107:94" xsi:type="EndsWith">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="157" locator="107:59-107:87" xsi:type="First">
                        <source localId="156" locator="107:65-107:86" xsi:type="Query">
                           <source alias="$this">
                              <expression localId="155" locator="107:65-107:76" path="insurance" scope="SR" xsi:type="Property"/>
                           </source>
                           <where xsi:type="Not">
                              <operand xsi:type="IsNull">
                                 <operand path="reference" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </operand>
                              </operand>
                           </where>
                           <return distinct="false">
                              <expression path="reference" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </return>
                        </source>
                     </operand>
                  </operand>
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="159" locator="107:90-107:93" path="id" scope="C" xsi:type="Property"/>
                  </operand>
               </suchThat>
            </relationship>
         </expression>
      </def>
      <def localId="176" locator="110:1-112:69" name="Billing Provider" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="176">
               <a:s>define &quot;Billing Provider&quot;:
 </a:s>
               <a:s r="175">
                  <a:s>singleton from</a:s>
                  <a:s r="174">
                     <a:s>(</a:s>
                     <a:s r="174">
                        <a:s>
                           <a:s r="165">
                              <a:s r="164">
                                 <a:s r="164">
                                    <a:s>[OrganizationProfile]</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  </a:s>
                        <a:s r="173">
                           <a:s>where </a:s>
                           <a:s r="173">
                              <a:s>EndsWith(</a:s>
                              <a:s r="170">
                                 <a:s>First(</a:s>
                                 <a:s r="169">
                                    <a:s r="168">
                                       <a:s r="167">
                                          <a:s r="166">
                                             <a:s>&quot;Test Coverage&quot;</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="167">
                                             <a:s>payor</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="168">
                                          <a:s>reference</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="169">
                                       <a:s>value</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="172">
                                 <a:s r="171">
                                    <a:s>O</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="172">
                                    <a:s>id</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="175" locator="111:2-112:69" xsi:type="SingletonFrom">
            <operand localId="174" locator="111:16-112:69" xsi:type="Query">
               <source localId="165" locator="111:17-111:39" alias="O">
                  <expression localId="164" locator="111:17-111:37" dataType="fhir:Organization" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" xsi:type="Retrieve"/>
               </source>
               <where localId="173" locator="112:3-112:68" xsi:type="EndsWith">
                  <operand localId="170" locator="112:18-112:61" xsi:type="First">
                     <source localId="169" locator="112:24-112:60" xsi:type="Query">
                        <source alias="$this">
                           <expression localId="168" locator="112:24-112:54" xsi:type="Query">
                              <source alias="$this">
                                 <expression localId="167" locator="112:24-112:44" xsi:type="Flatten">
                                    <operand xsi:type="Query">
                                       <source alias="$this">
                                          <expression localId="166" locator="112:24-112:38" name="Test Coverage" xsi:type="ExpressionRef"/>
                                       </source>
                                       <where xsi:type="Not">
                                          <operand xsi:type="IsNull">
                                             <operand path="payor" xsi:type="Property">
                                                <source name="$this" xsi:type="AliasRef"/>
                                             </operand>
                                          </operand>
                                       </where>
                                       <return distinct="false">
                                          <expression path="payor" xsi:type="Property">
                                             <source name="$this" xsi:type="AliasRef"/>
                                          </expression>
                                       </return>
                                    </operand>
                                 </expression>
                              </source>
                              <where xsi:type="Not">
                                 <operand xsi:type="IsNull">
                                    <operand path="reference" xsi:type="Property">
                                       <source name="$this" xsi:type="AliasRef"/>
                                    </operand>
                                 </operand>
                              </where>
                              <return distinct="false">
                                 <expression path="reference" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </expression>
                              </return>
                           </expression>
                        </source>
                        <where xsi:type="Not">
                           <operand xsi:type="IsNull">
                              <operand path="value" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </operand>
                           </operand>
                        </where>
                        <return distinct="false">
                           <expression path="value" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </expression>
                        </return>
                     </source>
                  </operand>
                  <operand localId="172" locator="112:64-112:67" path="value" xsi:type="Property">
                     <source path="id" scope="O" xsi:type="Property"/>
                  </operand>
               </where>
            </operand>
         </expression>
      </def>
      <def localId="179" locator="114:1-115:25" name="Billing Provider Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="179">
               <a:s>define &quot;Billing Provider Name&quot;:
  </a:s>
               <a:s r="178">
                  <a:s r="177">
                     <a:s>&quot;Billing Provider&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="178">
                     <a:s>name</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="178" locator="115:3-115:25" path="value" xsi:type="Property">
            <source path="name" xsi:type="Property">
               <source localId="177" locator="115:3-115:20" name="Billing Provider" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="185" locator="117:1-118:45" name="Billing Provider Phone" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="185">
               <a:s>define &quot;Billing Provider Phone&quot;:
  </a:s>
               <a:s r="184">
                  <a:s r="183">
                     <a:s r="180">
                        <a:s>UC</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="183">
                        <a:s>Mobile(</a:s>
                        <a:s r="182">
                           <a:s r="181">
                              <a:s>&quot;Billing Provider&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="182">
                              <a:s>telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="184">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="184" locator="118:3-118:45" path="value" xsi:type="Property">
            <source path="value" xsi:type="Property">
               <source localId="183" locator="118:3-118:39" name="Mobile" libraryName="UC" xsi:type="FunctionRef">
                  <operand localId="182" locator="118:13-118:38" path="telecom" xsi:type="Property">
                     <source localId="181" locator="118:13-118:30" name="Billing Provider" xsi:type="ExpressionRef"/>
                  </operand>
               </source>
            </source>
         </expression>
      </def>
      <def localId="196" locator="125:1-128:16" name="Billing Provider NPI" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="196">
               <a:s>// TODO: Error: Could not resolve data provider for package 'java.util'.
/*
define &quot;Billing Provider Address&quot;:
  (singleton from &quot;Billing Provider&quot;.address).line
*/
define &quot;Billing Provider NPI&quot;:
  </a:s>
               <a:s r="195">
                  <a:s>
                     <a:s r="187">
                        <a:s r="186">
                           <a:s>
                              <a:s>&quot;Billing Provider&quot;.identifier</a:s>
                           </a:s>
                        </a:s>
                        <a:s> I</a:s>
                     </a:s>
                  </a:s>
                  <a:s> 
  </a:s>
                  <a:s r="191">
                     <a:s>where </a:s>
                     <a:s r="191">
                        <a:s r="189">
                           <a:s r="188">
                              <a:s>I</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="189">
                              <a:s>system</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="190">
                           <a:s>'http://hl7.org/fhir/sid/us-npi'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="194">
                     <a:s>return </a:s>
                     <a:s r="193">
                        <a:s r="192">
                           <a:s>I</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="193">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="195" locator="126:3-128:16" xsi:type="Query">
            <source localId="187" locator="126:3-126:33" alias="I">
               <expression localId="186" locator="126:3-126:31" path="identifier" xsi:type="Property">
                  <source name="Billing Provider" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where localId="191" locator="127:3-127:51" xsi:type="Equal">
               <operand localId="189" locator="127:9-127:16" path="value" xsi:type="Property">
                  <source path="system" scope="I" xsi:type="Property"/>
               </operand>
               <operand localId="190" locator="127:20-127:51" valueType="t:String" value="http://hl7.org/fhir/sid/us-npi" xsi:type="Literal"/>
            </where>
            <return localId="194" locator="128:3-128:16">
               <expression localId="193" locator="128:10-128:16" path="value" xsi:type="Property">
                  <source path="value" scope="I" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="207" locator="130:1-133:16" name="Billing Provider Fax" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="207">
               <a:s>define &quot;Billing Provider Fax&quot;:
  </a:s>
               <a:s r="206">
                  <a:s>
                     <a:s r="198">
                        <a:s r="197">
                           <a:s>
                              <a:s>&quot;Billing Provider&quot;.telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s> T</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="202">
                     <a:s>where </a:s>
                     <a:s r="202">
                        <a:s r="200">
                           <a:s r="199">
                              <a:s>T</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="200">
                              <a:s>system</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="201">
                           <a:s>'fax'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="205">
                     <a:s>return </a:s>
                     <a:s r="204">
                        <a:s r="203">
                           <a:s>T</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="204">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="206" locator="131:3-133:16" xsi:type="Query">
            <source localId="198" locator="131:3-131:30" alias="T">
               <expression localId="197" locator="131:3-131:28" path="telecom" xsi:type="Property">
                  <source name="Billing Provider" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where localId="202" locator="132:3-132:24" xsi:type="Equal">
               <operand localId="200" locator="132:9-132:16" path="value" xsi:type="Property">
                  <source path="system" scope="T" xsi:type="Property"/>
               </operand>
               <operand localId="201" locator="132:20-132:24" valueType="t:String" value="fax" xsi:type="Literal"/>
            </where>
            <return localId="205" locator="133:3-133:16">
               <expression localId="204" locator="133:10-133:16" path="value" xsi:type="Property">
                  <source path="value" scope="T" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="211" locator="141:1-142:47" name="Date of Service" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="211">
               <a:s>define &quot;Date of Service&quot;:
  </a:s>
               <a:s r="210">
                  <a:s r="209">
                     <a:s r="208">
                        <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="209">
                        <a:s>occurrence</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="210">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="210" locator="142:3-142:47" path="value" xsi:type="Property">
            <source localId="209" locator="142:3-142:41" path="occurrence" xsi:type="Property">
               <source localId="208" locator="142:3-142:30" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="218" locator="144:1-146:16" name="Requested Test" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="218">
               <a:s>define &quot;Requested Test&quot;:
  </a:s>
               <a:s r="217">
                  <a:s>
                     <a:s r="213">
                        <a:s r="212">
                           <a:s>
                              <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> SR</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="216">
                     <a:s>return </a:s>
                     <a:s r="215">
                        <a:s r="214">
                           <a:s>SR</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="215">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="217" locator="145:3-146:16" xsi:type="Query">
            <source localId="213" locator="145:3-145:33" alias="SR">
               <expression localId="212" locator="145:3-145:30" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
            </source>
            <return localId="216" locator="146:3-146:16">
               <expression localId="215" locator="146:10-146:16" path="code" scope="SR" xsi:type="Property"/>
            </return>
         </expression>
      </def>
      <def localId="223" locator="148:1-149:36" name="Test ID" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="223">
               <a:s>define &quot;Test ID&quot;:
  </a:s>
               <a:s r="222">
                  <a:s r="221">
                     <a:s r="220">
                        <a:s r="219">
                           <a:s>&quot;Requested Test&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="220">
                           <a:s>coding</a:s>
                        </a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="221">
                        <a:s>code</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="222">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="222" locator="149:3-149:36" xsi:type="Query">
            <source alias="$this">
               <expression localId="221" locator="149:3-149:30" xsi:type="Query">
                  <source alias="$this">
                     <expression localId="220" locator="149:3-149:25" path="coding" xsi:type="Property">
                        <source localId="219" locator="149:3-149:18" name="Requested Test" xsi:type="ExpressionRef"/>
                     </expression>
                  </source>
                  <where xsi:type="Not">
                     <operand xsi:type="IsNull">
                        <operand path="code" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </operand>
                     </operand>
                  </where>
                  <return distinct="false">
                     <expression path="code" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </expression>
                  </return>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand path="value" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression path="value" xsi:type="Property">
                  <source name="$this" xsi:type="AliasRef"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="228" locator="151:1-152:40" name="Test name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="228">
               <a:s>define &quot;Test name&quot;:
   </a:s>
               <a:s r="227">
                  <a:s r="226">
                     <a:s r="225">
                        <a:s r="224">
                           <a:s>&quot;Requested Test&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="225">
                           <a:s>coding</a:s>
                        </a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="226">
                        <a:s>display</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="227">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="227" locator="152:4-152:40" xsi:type="Query">
            <source alias="$this">
               <expression localId="226" locator="152:4-152:34" xsi:type="Query">
                  <source alias="$this">
                     <expression localId="225" locator="152:4-152:26" path="coding" xsi:type="Property">
                        <source localId="224" locator="152:4-152:19" name="Requested Test" xsi:type="ExpressionRef"/>
                     </expression>
                  </source>
                  <where xsi:type="Not">
                     <operand xsi:type="IsNull">
                        <operand path="display" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </operand>
                     </operand>
                  </where>
                  <return distinct="false">
                     <expression path="display" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </expression>
                  </return>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand path="value" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression path="value" xsi:type="Property">
                  <source name="$this" xsi:type="AliasRef"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="239" locator="157:1-160:10" name="Test ICD Codes" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="239">
               <a:s>define &quot;Test ICD Codes&quot;:
 </a:s>
               <a:s r="238">
                  <a:s>
                     <a:s r="230">
                        <a:s r="229">
                           <a:s>
                              <a:s>&quot;Requested Test&quot;.coding</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="235">
                     <a:s>where </a:s>
                     <a:s r="235">
                        <a:s r="233">
                           <a:s r="232">
                              <a:s r="231">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="232">
                                 <a:s>system</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="233">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s> =  </a:s>
                        <a:s r="234">
                           <a:s>'http://hl7.org/fhir/sid/icd-10-cm'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="237">
                     <a:s>return </a:s>
                     <a:s r="236">
                        <a:s>C</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="238" locator="158:2-160:10" xsi:type="Query">
            <source localId="230" locator="158:2-158:26" alias="C">
               <expression localId="229" locator="158:2-158:24" path="coding" xsi:type="Property">
                  <source name="Requested Test" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where localId="235" locator="159:3-159:61" xsi:type="Equal">
               <operand localId="233" locator="159:9-159:22" path="value" xsi:type="Property">
                  <source localId="232" locator="159:9-159:16" path="system" scope="C" xsi:type="Property"/>
               </operand>
               <operand localId="234" locator="159:27-159:61" valueType="t:String" value="http://hl7.org/fhir/sid/icd-10-cm" xsi:type="Literal"/>
            </where>
            <return localId="237" locator="160:3-160:10">
               <expression localId="236" locator="160:10" name="C" xsi:type="AliasRef"/>
            </return>
         </expression>
      </def>
      <def localId="251" locator="162:1-165:10" name="Test CPT Codes" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="251">
               <a:s>define &quot;Test CPT Codes&quot;:
  </a:s>
               <a:s r="250">
                  <a:s>
                     <a:s r="242">
                        <a:s r="241">
                           <a:s>
                              <a:s>&quot;Requested Test&quot;.coding</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="247">
                     <a:s>where </a:s>
                     <a:s r="247">
                        <a:s r="245">
                           <a:s r="244">
                              <a:s r="243">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="244">
                                 <a:s>system</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="245">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s> =  </a:s>
                        <a:s r="246">
                           <a:s>'http://www.ama-assn.org/go/cpt'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="249">
                     <a:s>return </a:s>
                     <a:s r="248">
                        <a:s>C</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="250" locator="163:3-165:10" xsi:type="Query">
            <source localId="242" locator="163:3-163:27" alias="C">
               <expression localId="241" locator="163:3-163:25" path="coding" xsi:type="Property">
                  <source name="Requested Test" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where localId="247" locator="164:3-164:58" xsi:type="Equal">
               <operand localId="245" locator="164:9-164:22" path="value" xsi:type="Property">
                  <source localId="244" locator="164:9-164:16" path="system" scope="C" xsi:type="Property"/>
               </operand>
               <operand localId="246" locator="164:27-164:58" valueType="t:String" value="http://www.ama-assn.org/go/cpt" xsi:type="Literal"/>
            </where>
            <return localId="249" locator="165:3-165:10">
               <expression localId="248" locator="165:10" name="C" xsi:type="AliasRef"/>
            </return>
         </expression>
      </def>
      <def localId="257" locator="154:1-155:63" name="ALL ICD and CPT Test Codes" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="257">
               <a:s>define &quot;ALL ICD and CPT Test Codes&quot;:
   </a:s>
               <a:s r="256">
                  <a:s r="240">
                     <a:s>&quot;Test ICD Codes&quot;</a:s>
                  </a:s>
                  <a:s> union </a:s>
                  <a:s r="255">
                     <a:s r="252">
                        <a:s>&quot;Test CPT Codes&quot;</a:s>
                     </a:s>
                     <a:s> as </a:s>
                     <a:s r="254">
                        <a:s>List&lt;</a:s>
                        <a:s r="253">
                           <a:s>FHIR.Coding</a:s>
                        </a:s>
                        <a:s>></a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="256" locator="155:4-155:63" xsi:type="Union">
            <operand localId="240" locator="155:4-155:19" name="Test ICD Codes" xsi:type="ExpressionRef"/>
            <operand localId="255" locator="155:27-155:63" strict="false" xsi:type="As">
               <operand localId="252" locator="155:27-155:42" name="Test CPT Codes" xsi:type="ExpressionRef"/>
               <asTypeSpecifier localId="254" locator="155:47-155:63" xsi:type="ListTypeSpecifier">
                  <elementType localId="253" locator="155:52-155:62" name="fhir:Coding" xsi:type="NamedTypeSpecifier"/>
               </asTypeSpecifier>
            </operand>
         </expression>
      </def>
      <def localId="269" locator="167:1-169:91" name="Test Related Condition" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="269">
               <a:s>define &quot;Test Related Condition&quot;:
  </a:s>
               <a:s r="268">
                  <a:s>
                     <a:s r="259">
                        <a:s r="258">
                           <a:s r="258">
                              <a:s>[FHIR.Condition]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="267">
                     <a:s>where </a:s>
                     <a:s r="267">
                        <a:s>EndsWith(</a:s>
                        <a:s r="264">
                           <a:s>First(</a:s>
                           <a:s r="263">
                              <a:s r="262">
                                 <a:s r="261">
                                    <a:s r="260">
                                       <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="261">
                                       <a:s>reasonReference</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="262">
                                    <a:s>reference</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="263">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="266">
                           <a:s r="265">
                              <a:s>C</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="266">
                              <a:s>id</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="268" locator="168:3-169:91" xsi:type="Query">
            <source localId="259" locator="168:3-168:20" alias="C">
               <expression localId="258" locator="168:3-168:18" dataType="fhir:Condition" templateId="http://hl7.org/fhir/StructureDefinition/Condition" xsi:type="Retrieve"/>
            </source>
            <where localId="267" locator="169:3-169:91" xsi:type="EndsWith">
               <operand localId="264" locator="169:18-169:84" xsi:type="First">
                  <source localId="263" locator="169:24-169:83" xsi:type="Query">
                     <source alias="$this">
                        <expression localId="262" locator="169:24-169:77" xsi:type="Query">
                           <source alias="$this">
                              <expression localId="261" locator="169:24-169:67" path="reasonReference" xsi:type="Property">
                                 <source localId="260" locator="169:24-169:51" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
                              </expression>
                           </source>
                           <where xsi:type="Not">
                              <operand xsi:type="IsNull">
                                 <operand path="reference" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </operand>
                              </operand>
                           </where>
                           <return distinct="false">
                              <expression path="reference" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </return>
                        </expression>
                     </source>
                     <where xsi:type="Not">
                        <operand xsi:type="IsNull">
                           <operand path="value" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </operand>
                        </operand>
                     </where>
                     <return distinct="false">
                        <expression path="value" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </source>
               </operand>
               <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="266" locator="169:87-169:90" path="id" scope="C" xsi:type="Property"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="275" locator="172:1-173:52" name="Diagnosis Descriptions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="275">
               <a:s>//.reasonReference changed to .reason in FHIR R5
define &quot;Diagnosis Descriptions&quot;:
  </a:s>
               <a:s r="274">
                  <a:s r="273">
                     <a:s r="272">
                        <a:s r="271">
                           <a:s r="270">
                              <a:s>&quot;Test Related Condition&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="271">
                              <a:s>code</a:s>
                           </a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="272">
                           <a:s>coding</a:s>
                        </a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="273">
                        <a:s>display</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="274">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="274" locator="173:3-173:52" xsi:type="Query">
            <source alias="$this">
               <expression localId="273" locator="173:3-173:46" xsi:type="Query">
                  <source alias="$this">
                     <expression localId="272" locator="173:3-173:38" xsi:type="Flatten">
                        <operand xsi:type="Query">
                           <source alias="$this">
                              <expression localId="271" locator="173:3-173:31" xsi:type="Query">
                                 <source alias="$this">
                                    <expression localId="270" locator="173:3-173:26" name="Test Related Condition" xsi:type="ExpressionRef"/>
                                 </source>
                                 <where xsi:type="Not">
                                    <operand xsi:type="IsNull">
                                       <operand path="code" xsi:type="Property">
                                          <source name="$this" xsi:type="AliasRef"/>
                                       </operand>
                                    </operand>
                                 </where>
                                 <return distinct="false">
                                    <expression path="code" xsi:type="Property">
                                       <source name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </expression>
                           </source>
                           <where xsi:type="Not">
                              <operand xsi:type="IsNull">
                                 <operand path="coding" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </operand>
                              </operand>
                           </where>
                           <return distinct="false">
                              <expression path="coding" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </return>
                        </operand>
                     </expression>
                  </source>
                  <where xsi:type="Not">
                     <operand xsi:type="IsNull">
                        <operand path="display" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </operand>
                     </operand>
                  </where>
                  <return distinct="false">
                     <expression path="display" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </expression>
                  </return>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand path="value" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression path="value" xsi:type="Property">
                  <source name="$this" xsi:type="AliasRef"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="284" locator="175:1-179:6" name="Billing Provider different from Servicing Provider" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="284">
               <a:s>define &quot;Billing Provider different from Servicing Provider&quot;:
  </a:s>
               <a:s r="283">
                  <a:s>if </a:s>
                  <a:s r="280">
                     <a:s r="277">
                        <a:s r="276">
                           <a:s>&quot;Billing Provider&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="277">
                           <a:s>id</a:s>
                        </a:s>
                     </a:s>
                     <a:s> != </a:s>
                     <a:s r="279">
                        <a:s r="278">
                           <a:s>&quot;Servicing Provider&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="279">
                           <a:s>id</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s> then
  </a:s>
                  <a:s r="281">
                     <a:s>'Yes'</a:s>
                  </a:s>
                  <a:s>
  else 
  </a:s>
                  <a:s r="282">
                     <a:s>'No'</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="283" locator="176:3-179:6" xsi:type="If">
            <condition localId="280" locator="176:6-176:53" xsi:type="Not">
               <operand locator="176:6-176:53" xsi:type="Equal">
                  <operand localId="277" locator="176:6-176:26" path="value" xsi:type="Property">
                     <source path="id" xsi:type="Property">
                        <source localId="276" locator="176:6-176:23" name="Billing Provider" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
                  <operand localId="279" locator="176:31-176:53" path="value" xsi:type="Property">
                     <source path="id" xsi:type="Property">
                        <source localId="278" locator="176:31-176:50" name="Servicing Provider" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
               </operand>
            </condition>
            <then localId="281" locator="177:3-177:7" valueType="t:String" value="Yes" xsi:type="Literal"/>
            <else localId="282" locator="179:3-179:6" valueType="t:String" value="No" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="298" locator="198:1-200:56" name="Research Subject" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="298">
               <a:s>define &quot;Research Subject&quot;:
     </a:s>
               <a:s r="297">
                  <a:s>
                     <a:s r="290">
                        <a:s r="289">
                           <a:s r="289">
                              <a:s>[FHIR.ResearchSubject]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> R</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
     </a:s>
                  <a:s r="296">
                     <a:s>where  </a:s>
                     <a:s r="296">
                        <a:s>EndsWith(</a:s>
                        <a:s r="293">
                           <a:s r="292">
                              <a:s r="291">
                                 <a:s>R</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="292">
                                 <a:s>individual</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="293">
                              <a:s>reference</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="295">
                           <a:s r="294">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="295">
                              <a:s>id</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="297" locator="199:6-200:56" xsi:type="Query">
            <source localId="290" locator="199:6-199:29" alias="R">
               <expression localId="289" locator="199:6-199:27" dataType="fhir:ResearchSubject" templateId="http://hl7.org/fhir/StructureDefinition/ResearchSubject" xsi:type="Retrieve"/>
            </source>
            <where localId="296" locator="200:6-200:56" xsi:type="EndsWith">
               <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="293" locator="200:22-200:43" path="reference" xsi:type="Property">
                     <source localId="292" locator="200:22-200:33" path="individual" scope="R" xsi:type="Property"/>
                  </operand>
               </operand>
               <operand localId="295" locator="200:46-200:55" path="value" xsi:type="Property">
                  <source path="id" xsi:type="Property">
                     <source localId="294" locator="200:46-200:52" name="Patient" xsi:type="ExpressionRef"/>
                  </source>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="317" locator="205:1-208:66" name="Clinical Trial" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="317">
               <a:s>define &quot;Clinical Trial&quot;:
  </a:s>
               <a:s r="316">
                  <a:s>
                     <a:s r="288">
                        <a:s r="287">
                           <a:s r="287">
                              <a:s>[FHIR.ResearchStudy]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> R</a:s>
                     </a:s>
                  </a:s>
                  <a:s> 
  </a:s>
                  <a:s r="307">
                     <a:s>with </a:s>
                     <a:s r="300">
                        <a:s r="299">
                           <a:s>
                              <a:s>&quot;Research Subject&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> S</a:s>
                     </a:s>
                     <a:s> such that </a:s>
                     <a:s r="306">
                        <a:s>EndsWith(</a:s>
                        <a:s r="303">
                           <a:s r="302">
                              <a:s r="301">
                                 <a:s>S</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="302">
                                 <a:s>study</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="303">
                              <a:s>reference</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="305">
                           <a:s r="304">
                              <a:s>R</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="305">
                              <a:s>id</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="315">
                     <a:s>with  </a:s>
                     <a:s r="309">
                        <a:s r="308">
                           <a:s>
                              <a:s>&quot;Test Related Condition&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                     <a:s> such that </a:s>
                     <a:s r="314">
                        <a:s r="311">
                           <a:s r="310">
                              <a:s>C</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="311">
                              <a:s>code</a:s>
                           </a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="313">
                           <a:s r="312">
                              <a:s>R</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="313">
                              <a:s>condition</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="316" locator="206:3-208:66" xsi:type="Query">
            <source localId="288" locator="206:3-206:24" alias="R">
               <expression localId="287" locator="206:3-206:22" dataType="fhir:ResearchStudy" templateId="http://hl7.org/fhir/StructureDefinition/ResearchStudy" xsi:type="Retrieve"/>
            </source>
            <relationship localId="307" locator="207:3-207:71" alias="S" xsi:type="With">
               <expression localId="299" locator="207:8-207:25" name="Research Subject" xsi:type="ExpressionRef"/>
               <suchThat localId="306" locator="207:39-207:71" xsi:type="EndsWith">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="303" locator="207:48-207:64" path="reference" xsi:type="Property">
                        <source localId="302" locator="207:48-207:54" path="study" scope="S" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="305" locator="207:67-207:70" path="id" scope="R" xsi:type="Property"/>
                  </operand>
               </suchThat>
            </relationship>
            <relationship localId="315" locator="208:3-208:66" alias="C" xsi:type="With">
               <expression localId="308" locator="208:9-208:32" name="Test Related Condition" xsi:type="ExpressionRef"/>
               <suchThat localId="314" locator="208:46-208:66" xsi:type="In">
                  <operand localId="311" locator="208:46-208:51" path="code" scope="C" xsi:type="Property"/>
                  <operand localId="313" locator="208:56-208:66" path="condition" scope="R" xsi:type="Property"/>
               </suchThat>
            </relationship>
         </expression>
      </def>
      <def localId="329" locator="181:1-183:72" name="Clinical Trial Organization" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="329">
               <a:s>define &quot;Clinical Trial Organization&quot;:
  </a:s>
               <a:s r="328">
                  <a:s>First(</a:s>
                  <a:s r="327">
                     <a:s>
                        <a:s r="286">
                           <a:s r="285">
                              <a:s r="285">
                                 <a:s>[OrganizationProfile]</a:s>
                              </a:s>
                           </a:s>
                           <a:s> O</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
 </a:s>
                     <a:s r="326">
                        <a:s>with </a:s>
                        <a:s r="319">
                           <a:s r="318">
                              <a:s>
                                 <a:s>&quot;Clinical Trial&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>  T</a:s>
                        </a:s>
                        <a:s> such that </a:s>
                        <a:s r="325">
                           <a:s>EndsWith(</a:s>
                           <a:s r="322">
                              <a:s r="321">
                                 <a:s r="320">
                                    <a:s>T</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="321">
                                    <a:s>sponsor</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="322">
                                 <a:s>reference</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="324">
                              <a:s r="323">
                                 <a:s>O</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="324">
                                 <a:s>id</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="328" locator="182:3-183:72" xsi:type="First">
            <source localId="327" locator="182:9-183:71" xsi:type="Query">
               <source localId="286" locator="182:9-182:31" alias="O">
                  <expression localId="285" locator="182:9-182:29" dataType="fhir:Organization" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" xsi:type="Retrieve"/>
               </source>
               <relationship localId="326" locator="183:2-183:71" alias="T" xsi:type="With">
                  <expression localId="318" locator="183:7-183:22" name="Clinical Trial" xsi:type="ExpressionRef"/>
                  <suchThat localId="325" locator="183:37-183:71" xsi:type="EndsWith">
                     <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand localId="322" locator="183:46-183:64" path="reference" xsi:type="Property">
                           <source localId="321" locator="183:46-183:54" path="sponsor" scope="T" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand localId="324" locator="183:67-183:70" path="value" xsi:type="Property">
                        <source path="id" scope="O" xsi:type="Property"/>
                     </operand>
                  </suchThat>
               </relationship>
            </source>
         </expression>
      </def>
      <def localId="333" locator="185:1-186:52" name="BillingProvider is Clinical Trial Organisation" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="333">
               <a:s>//in FHIR R5 T.associatedParty instead of T.sponsor
define &quot;BillingProvider is Clinical Trial Organisation&quot;:
  </a:s>
               <a:s r="332">
                  <a:s r="330">
                     <a:s>&quot;Billing Provider&quot;</a:s>
                  </a:s>
                  <a:s> = </a:s>
                  <a:s r="331">
                     <a:s>&quot;Clinical Trial Organization&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="332" locator="186:3-186:52" xsi:type="Equal">
            <operand localId="330" locator="186:3-186:20" name="Billing Provider" xsi:type="ExpressionRef"/>
            <operand localId="331" locator="186:24-186:52" name="Clinical Trial Organization" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="336" locator="195:1-196:28" name="Is Research Subject" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="336">
               <a:s>define &quot;Is Research Subject&quot;:
  </a:s>
               <a:s r="335">
                  <a:s>exists</a:s>
                  <a:s r="334">
                     <a:s>(</a:s>
                     <a:s r="334">
                        <a:s>&quot;Research Subject&quot;</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="335" locator="196:3-196:28" xsi:type="Exists">
            <operand localId="334" locator="196:9-196:28" name="Research Subject" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="343" locator="189:1-193:5" name="Part of clinical trial" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="343">
               <a:s>//TODO does not get populated properly
define &quot;Part of clinical trial&quot;:
 </a:s>
               <a:s r="342">
                  <a:s>if </a:s>
                  <a:s r="339">
                     <a:s r="337">
                        <a:s>&quot;Is Research Subject&quot;</a:s>
                     </a:s>
                     <a:s> and </a:s>
                     <a:s r="338">
                        <a:s>&quot;BillingProvider is Clinical Trial Organisation&quot;</a:s>
                     </a:s>
                  </a:s>
                  <a:s> then
 </a:s>
                  <a:s r="340">
                     <a:s>'Yes'</a:s>
                  </a:s>
                  <a:s>
 else
 </a:s>
                  <a:s r="341">
                     <a:s>'No'</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="342" locator="190:2-193:5" xsi:type="If">
            <condition localId="339" locator="190:5-190:78" xsi:type="And">
               <operand localId="337" locator="190:5-190:25" name="Is Research Subject" xsi:type="ExpressionRef"/>
               <operand localId="338" locator="190:31-190:78" name="BillingProvider is Clinical Trial Organisation" xsi:type="ExpressionRef"/>
            </condition>
            <then localId="340" locator="191:2-191:6" valueType="t:String" value="Yes" xsi:type="Literal"/>
            <else localId="341" locator="193:2-193:5" valueType="t:String" value="No" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="347" locator="202:1-203:22" name="All clinical Trials" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="347">
               <a:s>//ResearchSubject.individual is from FHIR version v4.0.1 and has been replaced by R.subject in FHIR R5
define &quot;All clinical Trials&quot;:
</a:s>
               <a:s r="346">
                  <a:s>
                     <a:s r="345">
                        <a:s r="344">
                           <a:s r="344">
                              <a:s>[FHIR.ResearchStudy]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> R</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="346" locator="203:1-203:22" xsi:type="Query">
            <source localId="345" locator="203:1-203:22" alias="R">
               <expression localId="344" locator="203:1-203:20" dataType="fhir:ResearchStudy" templateId="http://hl7.org/fhir/StructureDefinition/ResearchStudy" xsi:type="Retrieve"/>
            </source>
         </expression>
      </def>
      <def localId="359" locator="210:1-213:22" name="Clinical Trial ID" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="359">
               <a:s>define &quot;Clinical Trial ID&quot;:
  </a:s>
               <a:s r="358">
                  <a:s>
                     <a:s r="349">
                        <a:s r="348">
                           <a:s>
                              <a:s>&quot;Clinical Trial&quot;.identifier</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="353">
                     <a:s>where </a:s>
                     <a:s r="353">
                        <a:s r="351">
                           <a:s r="350">
                              <a:s>C</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="351">
                              <a:s>system</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="352">
                           <a:s>'https://clinicaltrials.gov'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="357">
                     <a:s>return </a:s>
                     <a:s r="356">
                        <a:s r="355">
                           <a:s r="354">
                              <a:s>C</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="355">
                              <a:s>value</a:s>
                           </a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="356">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="358" locator="211:3-213:22" xsi:type="Query">
            <source localId="349" locator="211:3-211:31" alias="C">
               <expression localId="348" locator="211:3-211:29" xsi:type="Flatten">
                  <operand xsi:type="Query">
                     <source alias="$this">
                        <expression name="Clinical Trial" xsi:type="ExpressionRef"/>
                     </source>
                     <where xsi:type="Not">
                        <operand xsi:type="IsNull">
                           <operand path="identifier" xsi:type="Property">
                              <source name="$this" xsi:type="AliasRef"/>
                           </operand>
                        </operand>
                     </where>
                     <return distinct="false">
                        <expression path="identifier" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
               </expression>
            </source>
            <where localId="353" locator="212:3-212:47" xsi:type="Equal">
               <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand localId="351" locator="212:9-212:16" path="system" scope="C" xsi:type="Property"/>
               </operand>
               <operand localId="352" locator="212:20-212:47" valueType="t:String" value="https://clinicaltrials.gov" xsi:type="Literal"/>
            </where>
            <return localId="357" locator="213:3-213:22">
               <expression localId="356" locator="213:10-213:22" path="value" xsi:type="Property">
                  <source localId="355" locator="213:10-213:16" path="value" scope="C" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="376" locator="216:1-219:10" name="GetServiceRequestReasonCondition" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="376">
               <a:s>define function &quot;GetServiceRequestReasonCondition&quot;(S </a:s>
               <a:s r="360">
                  <a:s>ServiceRequest</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="375">
                  <a:s r="375">
                     <a:s>
                        <a:s r="362">
                           <a:s r="361">
                              <a:s r="361">
                                 <a:s>[FHIR.Condition]</a:s>
                              </a:s>
                           </a:s>
                           <a:s> C</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  </a:s>
                     <a:s r="372">
                        <a:s>with  </a:s>
                        <a:s r="364">
                           <a:s r="363">
                              <a:s>
                                 <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s> SR</a:s>
                        </a:s>
                        <a:s> such that  </a:s>
                        <a:s r="371">
                           <a:s>EndsWith(</a:s>
                           <a:s r="368">
                              <a:s>First(</a:s>
                              <a:s r="367">
                                 <a:s r="366">
                                    <a:s r="365">
                                       <a:s>SR</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="366">
                                       <a:s>insurance</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="367">
                                    <a:s>reference</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="370">
                              <a:s r="369">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="370">
                                 <a:s>id</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  </a:s>
                     <a:s r="374">
                        <a:s>return </a:s>
                        <a:s r="373">
                           <a:s>C</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="375" locator="217:3-219:10" xsi:type="Query">
            <source localId="362" locator="217:3-217:20" alias="C">
               <expression localId="361" locator="217:3-217:18" dataType="fhir:Condition" templateId="http://hl7.org/fhir/StructureDefinition/Condition" xsi:type="Retrieve"/>
            </source>
            <relationship localId="372" locator="218:3-218:96" alias="SR" xsi:type="With">
               <expression localId="363" locator="218:9-218:36" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
               <suchThat localId="371" locator="218:52-218:96" xsi:type="EndsWith">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="368" locator="218:61-218:89" xsi:type="First">
                        <source localId="367" locator="218:67-218:88" xsi:type="Query">
                           <source alias="$this">
                              <expression localId="366" locator="218:67-218:78" path="insurance" scope="SR" xsi:type="Property"/>
                           </source>
                           <where xsi:type="Not">
                              <operand xsi:type="IsNull">
                                 <operand path="reference" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </operand>
                              </operand>
                           </where>
                           <return distinct="false">
                              <expression path="reference" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </return>
                        </source>
                     </operand>
                  </operand>
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="370" locator="218:92-218:95" path="id" scope="C" xsi:type="Property"/>
                  </operand>
               </suchThat>
            </relationship>
            <return localId="374" locator="219:3-219:10">
               <expression localId="373" locator="219:10" name="C" xsi:type="AliasRef"/>
            </return>
         </expression>
         <operand name="S">
            <operandTypeSpecifier localId="360" locator="216:54-216:67" name="fhir:ServiceRequest" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="403" locator="222:1-228:19" name="Previous genetic testing for condition" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="403">
               <a:s>define &quot;Previous genetic testing for condition&quot;:
   </a:s>
               <a:s r="402">
                  <a:s>
                     <a:s>from </a:s>
                     <a:s r="378">
                        <a:s r="377">
                           <a:s>
                              <a:s>&quot;All ServiceRequests&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> S</a:s>
                     </a:s>
                     <a:s>,
   </a:s>
                     <a:s r="380">
                        <a:s r="379">
                           <a:s>
                              <a:s>&quot;Most Recent ServiceRequest&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> SR</a:s>
                     </a:s>
                  </a:s>
                  <a:s> 
   </a:s>
                  <a:s r="397">
                     <a:s>where </a:s>
                     <a:s r="397">
                        <a:s r="391">
                           <a:s r="385">
                              <a:s r="382">
                                 <a:s r="381">
                                    <a:s>S</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="382">
                                    <a:s>occurrence</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="385"> before </a:s>
                              <a:s r="384">
                                 <a:s r="383">
                                    <a:s>SR</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="384">
                                    <a:s>occurrence</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
   and </a:s>
                           <a:s r="390">
                              <a:s r="387">
                                 <a:s r="386">
                                    <a:s>S</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="387">
                                    <a:s>id</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> != </a:s>
                              <a:s r="389">
                                 <a:s r="388">
                                    <a:s>SR</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="389">
                                    <a:s>id</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
   and </a:s>
                        <a:s r="396">
                           <a:s r="393">
                              <a:s r="392">
                                 <a:s>S</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="393">
                                 <a:s>reasonReference</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="395">
                              <a:s r="394">
                                 <a:s>SR</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="395">
                                 <a:s>reasonReference</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  </a:s>
                  <a:s r="401">
                     <a:s>return </a:s>
                     <a:s r="400">
                        <a:s r="399">
                           <a:s r="398">
                              <a:s>S</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="399">
                              <a:s>id</a:s>
                           </a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="400">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="402" locator="223:4-228:19" xsi:type="Query">
            <source localId="378" locator="223:9-223:31" alias="S">
               <expression localId="377" locator="223:9-223:29" name="All ServiceRequests" xsi:type="ExpressionRef"/>
            </source>
            <source localId="380" locator="224:4-224:34" alias="SR">
               <expression localId="379" locator="224:4-224:31" name="Most Recent ServiceRequest" xsi:type="ExpressionRef"/>
            </source>
            <where localId="397" locator="225:4-227:45" xsi:type="And">
               <operand localId="391" locator="225:10-226:20" xsi:type="And">
                  <operand localId="385" locator="225:10-225:42" xsi:type="Before">
                     <operand name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand asType="fhir:dateTime" xsi:type="As">
                           <operand localId="382" locator="225:10-225:21" path="occurrence" scope="S" xsi:type="Property"/>
                        </operand>
                     </operand>
                     <operand name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand asType="fhir:dateTime" xsi:type="As">
                           <operand localId="384" locator="225:30-225:42" path="occurrence" scope="SR" xsi:type="Property"/>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="390" locator="226:8-226:20" xsi:type="Not">
                     <operand locator="226:8-226:20" xsi:type="Equal">
                        <operand localId="387" locator="226:8-226:11" path="id" scope="S" xsi:type="Property"/>
                        <operand localId="389" locator="226:16-226:20" path="id" scope="SR" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="396" locator="227:8-227:45" xsi:type="Equal">
                  <operand localId="393" locator="227:8-227:24" path="reasonReference" scope="S" xsi:type="Property"/>
                  <operand localId="395" locator="227:28-227:45" path="reasonReference" scope="SR" xsi:type="Property"/>
               </operand>
            </where>
            <return localId="401" locator="228:3-228:19">
               <expression localId="400" locator="228:10-228:19" path="value" xsi:type="Property">
                  <source localId="399" locator="228:10-228:13" path="id" scope="S" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorVersion" : "2.7.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "403",
            "s" : [ {
               "value" : [ "","library GMTPInitialExpressions version '0.1.0'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "GMTPInitialExpressions",
         "system" : "http://fhir.org/guides/cqf/us/common",
         "version" : "0.1.0"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "3:1-3:28",
            "localIdentifier" : "USCore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCore" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.1.1'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "2",
            "locator" : "4:1-4:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "2",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIR" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.0.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "6:1-6:37",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/cqf/us/common/FHIRHelpers",
            "version" : "4.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "3",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.1.000'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "4",
            "locator" : "7:1-7:46",
            "localIdentifier" : "UC",
            "path" : "http://fhir.org/guides/cqf/us/common/USCoreCommon",
            "version" : "0.1.0",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "4",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'0.1.0'"," called ","UC" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "5",
            "locator" : "8:1-8:49",
            "localIdentifier" : "UCE",
            "path" : "http://fhir.org/guides/cqf/us/common/USCoreElements",
            "version" : "0.1.0",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "5",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCoreElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'0.1.0'"," called ","UCE" ]
                  } ]
               }
            } ]
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "6",
            "locator" : "10:1-10:38",
            "name" : "LOINC",
            "id" : "http://loinc.org",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "6",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"LOINC\"",": ","'http://loinc.org'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "7",
            "locator" : "11:1-11:77",
            "name" : "Identifier Type",
            "id" : "http://terminology.hl7.org/CodeSystem/v2-0203",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "7",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"Identifier Type\"",": ","'http://terminology.hl7.org/CodeSystem/v2-0203'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "9",
            "locator" : "12:1-12:49",
            "name" : "Member Number",
            "id" : "MB",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "9",
                  "s" : [ {
                     "value" : [ "","code ","\"Member Number\"",": ","'MB'"," from " ]
                  }, {
                     "r" : "8",
                     "s" : [ {
                        "value" : [ "\"Identifier Type\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "8",
               "locator" : "12:33-12:49",
               "name" : "Identifier Type"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "locator" : "15:1-15:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "15:1-15:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "15:1-15:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "42",
            "locator" : "17:1-29:5",
            "name" : "Humana ID",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "42",
                  "s" : [ {
                     "value" : [ "","define ","\"Humana ID\"",": // Similar to Member ID from MBODA Initial expressions?\n  " ]
                  }, {
                     "r" : "41",
                     "s" : [ {
                        "value" : [ "singleton from\n    " ]
                     }, {
                        "r" : "40",
                        "s" : [ {
                           "value" : [ "(\n      " ]
                        }, {
                           "r" : "40",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "31",
                                 "s" : [ {
                                    "r" : "30",
                                    "s" : [ {
                                       "value" : [ "(\n        " ]
                                    }, {
                                       "r" : "30",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "20",
                                             "s" : [ {
                                                "r" : "19",
                                                "s" : [ {
                                                   "value" : [ "(\n          " ]
                                                }, {
                                                   "r" : "19",
                                                   "s" : [ {
                                                      "r" : "18",
                                                      "s" : [ {
                                                         "value" : [ "(" ]
                                                      }, {
                                                         "r" : "18",
                                                         "s" : [ {
                                                            "s" : [ {
                                                               "r" : "11",
                                                               "s" : [ {
                                                                  "r" : "10",
                                                                  "s" : [ {
                                                                     "r" : "10",
                                                                     "s" : [ {
                                                                        "value" : [ "[","FHIR",".","Coverage","]" ]
                                                                     } ]
                                                                  } ]
                                                               }, {
                                                                  "value" : [ " ","C" ]
                                                               } ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " \n              " ]
                                                         }, {
                                                            "r" : "17",
                                                            "s" : [ {
                                                               "value" : [ "where " ]
                                                            }, {
                                                               "r" : "17",
                                                               "s" : [ {
                                                                  "value" : [ "EndsWith","(" ]
                                                               }, {
                                                                  "r" : "14",
                                                                  "s" : [ {
                                                                     "r" : "13",
                                                                     "s" : [ {
                                                                        "r" : "12",
                                                                        "s" : [ {
                                                                           "value" : [ "C" ]
                                                                        } ]
                                                                     }, {
                                                                        "value" : [ "." ]
                                                                     }, {
                                                                        "r" : "13",
                                                                        "s" : [ {
                                                                           "value" : [ "beneficiary" ]
                                                                        } ]
                                                                     } ]
                                                                  }, {
                                                                     "value" : [ "." ]
                                                                  }, {
                                                                     "r" : "14",
                                                                     "s" : [ {
                                                                        "value" : [ "reference" ]
                                                                     } ]
                                                                  } ]
                                                               }, {
                                                                  "value" : [ ", " ]
                                                               }, {
                                                                  "r" : "16",
                                                                  "s" : [ {
                                                                     "r" : "15",
                                                                     "s" : [ {
                                                                        "value" : [ "Patient" ]
                                                                     } ]
                                                                  }, {
                                                                     "value" : [ "." ]
                                                                  }, {
                                                                     "r" : "16",
                                                                     "s" : [ {
                                                                        "value" : [ "id" ]
                                                                     } ]
                                                                  } ]
                                                               }, {
                                                                  "value" : [ ")" ]
                                                               } ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "\n          ." ]
                                                   }, {
                                                      "r" : "19",
                                                      "s" : [ {
                                                         "value" : [ "identifier" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             }, {
                                                "value" : [ " ","I" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "29",
                                          "s" : [ {
                                             "value" : [ "return " ]
                                          }, {
                                             "r" : "28",
                                             "s" : [ {
                                                "value" : [ "{" ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "value",": " ]
                                                }, {
                                                   "r" : "23",
                                                   "s" : [ {
                                                      "r" : "22",
                                                      "s" : [ {
                                                         "r" : "21",
                                                         "s" : [ {
                                                            "value" : [ "I" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "22",
                                                         "s" : [ {
                                                            "value" : [ "value" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "23",
                                                      "s" : [ {
                                                         "value" : [ "value" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ", " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "type",": " ]
                                                }, {
                                                   "r" : "27",
                                                   "s" : [ {
                                                      "r" : "26",
                                                      "s" : [ {
                                                         "r" : "25",
                                                         "s" : [ {
                                                            "r" : "24",
                                                            "s" : [ {
                                                               "value" : [ "I" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ "." ]
                                                         }, {
                                                            "r" : "25",
                                                            "s" : [ {
                                                               "value" : [ "type" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "26",
                                                         "s" : [ {
                                                            "value" : [ "coding" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "27",
                                                      "s" : [ {
                                                         "value" : [ "code" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "}" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n      )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","valuesByTypes" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    " ]
                           }, {
                              "r" : "36",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "36",
                                 "s" : [ {
                                    "r" : "33",
                                    "s" : [ {
                                       "r" : "32",
                                       "s" : [ {
                                          "value" : [ "\"Member Number\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "33",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " in " ]
                                 }, {
                                    "r" : "35",
                                    "s" : [ {
                                       "r" : "34",
                                       "s" : [ {
                                          "value" : [ "valuesByTypes" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "35",
                                       "s" : [ {
                                          "value" : [ "type" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    " ]
                           }, {
                              "r" : "39",
                              "s" : [ {
                                 "value" : [ "return " ]
                              }, {
                                 "r" : "38",
                                 "s" : [ {
                                    "r" : "37",
                                    "s" : [ {
                                       "value" : [ "valuesByTypes" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "38",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "41",
               "locator" : "18:3-29:5",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "40",
                  "locator" : "19:5-29:5",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "31",
                     "locator" : "20:7-26:21",
                     "alias" : "valuesByTypes",
                     "expression" : {
                        "localId" : "30",
                        "locator" : "20:7-26:7",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "20",
                           "locator" : "21:9-24:24",
                           "alias" : "I",
                           "expression" : {
                              "localId" : "19",
                              "locator" : "21:9-24:22",
                              "type" : "Flatten",
                              "operand" : {
                                 "type" : "Query",
                                 "source" : [ {
                                    "alias" : "$this",
                                    "expression" : {
                                       "localId" : "18",
                                       "locator" : "22:11-23:66",
                                       "type" : "Query",
                                       "source" : [ {
                                          "localId" : "11",
                                          "locator" : "22:12-22:28",
                                          "alias" : "C",
                                          "expression" : {
                                             "localId" : "10",
                                             "locator" : "22:12-22:26",
                                             "dataType" : "{http://hl7.org/fhir}Coverage",
                                             "templateId" : "http://hl7.org/fhir/StructureDefinition/Coverage",
                                             "type" : "Retrieve"
                                          }
                                       } ],
                                       "relationship" : [ ],
                                       "where" : {
                                          "localId" : "17",
                                          "locator" : "23:15-23:65",
                                          "type" : "EndsWith",
                                          "operand" : [ {
                                             "name" : "ToString",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "localId" : "14",
                                                "locator" : "23:30-23:52",
                                                "path" : "reference",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "13",
                                                   "locator" : "23:30-23:42",
                                                   "path" : "beneficiary",
                                                   "scope" : "C",
                                                   "type" : "Property"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "16",
                                             "locator" : "23:55-23:64",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "id",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "15",
                                                   "locator" : "23:55-23:61",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          } ]
                                       }
                                    }
                                 } ],
                                 "where" : {
                                    "type" : "Not",
                                    "operand" : {
                                       "type" : "IsNull",
                                       "operand" : {
                                          "path" : "identifier",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    }
                                 },
                                 "return" : {
                                    "distinct" : false,
                                    "expression" : {
                                       "path" : "identifier",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 }
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "return" : {
                           "localId" : "29",
                           "locator" : "25:9-25:63",
                           "expression" : {
                              "localId" : "28",
                              "locator" : "25:16-25:63",
                              "type" : "Tuple",
                              "element" : [ {
                                 "name" : "value",
                                 "value" : {
                                    "localId" : "23",
                                    "locator" : "25:24-25:36",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "22",
                                       "locator" : "25:24-25:30",
                                       "path" : "value",
                                       "scope" : "I",
                                       "type" : "Property"
                                    }
                                 }
                              }, {
                                 "name" : "type",
                                 "value" : {
                                    "localId" : "27",
                                    "locator" : "25:45-25:62",
                                    "type" : "Query",
                                    "source" : [ {
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "26",
                                          "locator" : "25:45-25:57",
                                          "path" : "coding",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "25",
                                             "locator" : "25:45-25:50",
                                             "path" : "type",
                                             "scope" : "I",
                                             "type" : "Property"
                                          }
                                       }
                                    } ],
                                    "where" : {
                                       "type" : "Not",
                                       "operand" : {
                                          "type" : "IsNull",
                                          "operand" : {
                                             "path" : "code",
                                             "type" : "Property",
                                             "source" : {
                                                "name" : "$this",
                                                "type" : "AliasRef"
                                             }
                                          }
                                       }
                                    },
                                    "return" : {
                                       "distinct" : false,
                                       "expression" : {
                                          "path" : "code",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    }
                                 }
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "36",
                     "locator" : "27:5-27:52",
                     "type" : "In",
                     "operand" : [ {
                        "localId" : "33",
                        "locator" : "27:11-27:30",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "32",
                           "locator" : "27:11-27:25",
                           "name" : "Member Number",
                           "type" : "CodeRef"
                        }
                     }, {
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "X",
                           "expression" : {
                              "localId" : "35",
                              "locator" : "27:35-27:52",
                              "path" : "type",
                              "scope" : "valuesByTypes",
                              "type" : "Property"
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "X",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     } ]
                  },
                  "return" : {
                     "localId" : "39",
                     "locator" : "28:5-28:30",
                     "expression" : {
                        "localId" : "38",
                        "locator" : "28:12-28:30",
                        "path" : "value",
                        "scope" : "valuesByTypes",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "45",
            "locator" : "31:1-32:35",
            "name" : "Patient Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "45",
                  "s" : [ {
                     "value" : [ "","define ","\"Patient Name\"",":\n  " ]
                  }, {
                     "r" : "44",
                     "s" : [ {
                        "r" : "43",
                        "s" : [ {
                           "value" : [ "UCE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "44",
                        "s" : [ {
                           "value" : [ "\"Name - First Middle(s) Last\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "44",
               "locator" : "32:3-32:35",
               "name" : "Name - First Middle(s) Last",
               "libraryName" : "UCE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "48",
            "locator" : "34:1-35:19",
            "name" : "Date of Birth",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "48",
                  "s" : [ {
                     "value" : [ "","define ","\"Date of Birth\"",":\n  " ]
                  }, {
                     "r" : "47",
                     "s" : [ {
                        "r" : "46",
                        "s" : [ {
                           "value" : [ "Patient" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "47",
                        "s" : [ {
                           "value" : [ "birthDate" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "47",
               "locator" : "35:3-35:19",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "birthDate",
                  "type" : "Property",
                  "source" : {
                     "localId" : "46",
                     "locator" : "35:3-35:9",
                     "name" : "Patient",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "54",
            "locator" : "37:1-38:34",
            "name" : "Phone Number",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "54",
                  "s" : [ {
                     "value" : [ "","define ","\"Phone Number\"",":\n  " ]
                  }, {
                     "r" : "53",
                     "s" : [ {
                        "r" : "52",
                        "s" : [ {
                           "r" : "49",
                           "s" : [ {
                              "value" : [ "UC" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "52",
                           "s" : [ {
                              "value" : [ "Mobile","(" ]
                           }, {
                              "r" : "51",
                              "s" : [ {
                                 "r" : "50",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "51",
                                 "s" : [ {
                                    "value" : [ "telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "53",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "53",
               "locator" : "38:3-38:34",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "localId" : "52",
                     "locator" : "38:3-38:28",
                     "name" : "Mobile",
                     "libraryName" : "UC",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "51",
                        "locator" : "38:13-38:27",
                        "path" : "telecom",
                        "type" : "Property",
                        "source" : {
                           "localId" : "50",
                           "locator" : "38:13-38:19",
                           "name" : "Patient",
                           "type" : "ExpressionRef"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "59",
            "locator" : "135:1-136:23",
            "name" : "All ServiceRequests",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "59",
                  "s" : [ {
                     "value" : [ "","define ","\"All ServiceRequests\"",":\n  " ]
                  }, {
                     "r" : "58",
                     "s" : [ {
                        "value" : [ "[","FHIR",".","ServiceRequest","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "58",
               "locator" : "136:3-136:23",
               "dataType" : "{http://hl7.org/fhir}ServiceRequest",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/ServiceRequest",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "62",
            "locator" : "138:1-139:40",
            "name" : "Most Recent ServiceRequest",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "62",
                  "s" : [ {
                     "value" : [ "","define ","\"Most Recent ServiceRequest\"",":\n  " ]
                  }, {
                     "r" : "61",
                     "s" : [ {
                        "r" : "57",
                        "s" : [ {
                           "value" : [ "UC" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "61",
                        "s" : [ {
                           "value" : [ "MostRecentSR","(" ]
                        }, {
                           "r" : "60",
                           "s" : [ {
                              "value" : [ "\"All ServiceRequests\"" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "61",
               "locator" : "139:3-139:40",
               "name" : "MostRecentSR",
               "libraryName" : "UC",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "60",
                  "locator" : "139:19-139:39",
                  "name" : "All ServiceRequests",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "71",
            "locator" : "46:1-48:80",
            "name" : "Requesting Provider Practitioner",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "71",
                  "s" : [ {
                     "value" : [ "// TODO: Error: Could not resolve data provider for package 'java.util'.\n/*\ndefine \"Address\":\n   (singleton from Patient.address).line\n*/\n","define ","\"Requesting Provider Practitioner\"","://assuming the requester is a practitioner\n  " ]
                  }, {
                     "r" : "70",
                     "s" : [ {
                        "s" : [ {
                           "r" : "56",
                           "s" : [ {
                              "r" : "55",
                              "s" : [ {
                                 "r" : "55",
                                 "s" : [ {
                                    "value" : [ "[","PractitionerProfile","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","P" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "69",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "69",
                           "s" : [ {
                              "value" : [ "EndsWith","(" ]
                           }, {
                              "r" : "66",
                              "s" : [ {
                                 "r" : "65",
                                 "s" : [ {
                                    "r" : "64",
                                    "s" : [ {
                                       "r" : "63",
                                       "s" : [ {
                                          "value" : [ "\"Most Recent ServiceRequest\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "64",
                                       "s" : [ {
                                          "value" : [ "requester" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "65",
                                    "s" : [ {
                                       "value" : [ "reference" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "66",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "68",
                              "s" : [ {
                                 "r" : "67",
                                 "s" : [ {
                                    "value" : [ "P" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "68",
                                 "s" : [ {
                                    "value" : [ "id" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "70",
               "locator" : "47:3-48:80",
               "type" : "Query",
               "source" : [ {
                  "localId" : "56",
                  "locator" : "47:3-47:25",
                  "alias" : "P",
                  "expression" : {
                     "localId" : "55",
                     "locator" : "47:3-47:23",
                     "dataType" : "{http://hl7.org/fhir}Practitioner",
                     "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "69",
                  "locator" : "48:5-48:80",
                  "type" : "EndsWith",
                  "operand" : [ {
                     "localId" : "66",
                     "locator" : "48:20-48:73",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "65",
                        "locator" : "48:20-48:67",
                        "path" : "reference",
                        "type" : "Property",
                        "source" : {
                           "localId" : "64",
                           "locator" : "48:20-48:57",
                           "path" : "requester",
                           "type" : "Property",
                           "source" : {
                              "localId" : "63",
                              "locator" : "48:20-48:47",
                              "name" : "Most Recent ServiceRequest",
                              "type" : "ExpressionRef"
                           }
                        }
                     }
                  }, {
                     "localId" : "68",
                     "locator" : "48:76-48:79",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "id",
                        "scope" : "P",
                        "type" : "Property"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "73",
            "locator" : "56:1-57:37",
            "name" : "Requesting Provider",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "73",
                  "s" : [ {
                     "value" : [ "/*//if the requester is an Organization:\ndefine \"Requesting Provider Organization\":\n  [OrganizationProfile] O\n    where EndsWith(\"Most Recent ServiceRequest\".requester.reference.value, O.id)\n */\n","define ","\"Requesting Provider\"",":\n   " ]
                  }, {
                     "r" : "72",
                     "s" : [ {
                        "value" : [ "\"Requesting Provider Practitioner\"" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "72",
               "locator" : "57:4-57:37",
               "name" : "Requesting Provider Practitioner",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "77",
            "locator" : "60:1-61:35",
            "name" : "Requesting Provider Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "77",
                  "s" : [ {
                     "value" : [ "","define ","\"Requesting Provider Name\"",":\n  " ]
                  }, {
                     "r" : "76",
                     "s" : [ {
                        "r" : "75",
                        "s" : [ {
                           "r" : "74",
                           "s" : [ {
                              "value" : [ "\"Requesting Provider\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "75",
                           "s" : [ {
                              "value" : [ "name" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "76",
                        "s" : [ {
                           "value" : [ "family" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "76",
               "locator" : "61:3-61:35",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "75",
                     "locator" : "61:3-61:28",
                     "type" : "Flatten",
                     "operand" : {
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "localId" : "74",
                              "locator" : "61:3-61:23",
                              "name" : "Requesting Provider",
                              "type" : "ExpressionRef"
                           }
                        } ],
                        "where" : {
                           "type" : "Not",
                           "operand" : {
                              "type" : "IsNull",
                              "operand" : {
                                 "path" : "name",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        },
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "path" : "name",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "family",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        }
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "family",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               }
            }
         }, {
            "localId" : "83",
            "locator" : "63:1-64:48",
            "name" : "Requesting Provider Phone",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "83",
                  "s" : [ {
                     "value" : [ "","define ","\"Requesting Provider Phone\"",":\n  " ]
                  }, {
                     "r" : "82",
                     "s" : [ {
                        "r" : "81",
                        "s" : [ {
                           "r" : "78",
                           "s" : [ {
                              "value" : [ "UC" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "81",
                           "s" : [ {
                              "value" : [ "Mobile","(" ]
                           }, {
                              "r" : "80",
                              "s" : [ {
                                 "r" : "79",
                                 "s" : [ {
                                    "value" : [ "\"Requesting Provider\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "80",
                                 "s" : [ {
                                    "value" : [ "telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "82",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "82",
               "locator" : "64:3-64:48",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "localId" : "81",
                     "locator" : "64:3-64:42",
                     "name" : "Mobile",
                     "libraryName" : "UC",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "80",
                        "locator" : "64:13-64:41",
                        "type" : "Flatten",
                        "operand" : {
                           "type" : "Query",
                           "source" : [ {
                              "alias" : "$this",
                              "expression" : {
                                 "localId" : "79",
                                 "locator" : "64:13-64:33",
                                 "name" : "Requesting Provider",
                                 "type" : "ExpressionRef"
                              }
                           } ],
                           "where" : {
                              "type" : "Not",
                              "operand" : {
                                 "type" : "IsNull",
                                 "operand" : {
                                    "path" : "telecom",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           },
                           "return" : {
                              "distinct" : false,
                              "expression" : {
                                 "path" : "telecom",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "94",
            "locator" : "69:1-72:16",
            "name" : "Requesting Provider NPI",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "94",
                  "s" : [ {
                     "value" : [ "/*\ndefine \"Requesting Provider Address\":\n  (singleton from \"Requesting Provider\".address).line\n*/\n","define ","\"Requesting Provider NPI\"",":\n  " ]
                  }, {
                     "r" : "93",
                     "s" : [ {
                        "s" : [ {
                           "r" : "85",
                           "s" : [ {
                              "r" : "84",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Requesting Provider\"",".","identifier" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","I" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " \n  " ]
                     }, {
                        "r" : "89",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "89",
                           "s" : [ {
                              "r" : "87",
                              "s" : [ {
                                 "r" : "86",
                                 "s" : [ {
                                    "value" : [ "I" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "87",
                                 "s" : [ {
                                    "value" : [ "system" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "88",
                              "s" : [ {
                                 "value" : [ "'http://hl7.org/fhir/sid/us-npi'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "92",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "91",
                           "s" : [ {
                              "r" : "90",
                              "s" : [ {
                                 "value" : [ "I" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "91",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "93",
               "locator" : "70:3-72:16",
               "type" : "Query",
               "source" : [ {
                  "localId" : "85",
                  "locator" : "70:3-70:36",
                  "alias" : "I",
                  "expression" : {
                     "localId" : "84",
                     "locator" : "70:3-70:34",
                     "type" : "Flatten",
                     "operand" : {
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "name" : "Requesting Provider",
                              "type" : "ExpressionRef"
                           }
                        } ],
                        "where" : {
                           "type" : "Not",
                           "operand" : {
                              "type" : "IsNull",
                              "operand" : {
                                 "path" : "identifier",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        },
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "path" : "identifier",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "89",
                  "locator" : "71:3-71:51",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "87",
                     "locator" : "71:9-71:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "system",
                        "scope" : "I",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "88",
                     "locator" : "71:20-71:51",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "http://hl7.org/fhir/sid/us-npi",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "92",
                  "locator" : "72:3-72:16",
                  "expression" : {
                     "localId" : "91",
                     "locator" : "72:10-72:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "value",
                        "scope" : "I",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "105",
            "locator" : "74:1-77:16",
            "name" : "Requesting Provider Fax",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "105",
                  "s" : [ {
                     "value" : [ "","define ","\"Requesting Provider Fax\"",":\n  " ]
                  }, {
                     "r" : "104",
                     "s" : [ {
                        "s" : [ {
                           "r" : "96",
                           "s" : [ {
                              "r" : "95",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Requesting Provider\"",".","telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","T" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "100",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "100",
                           "s" : [ {
                              "r" : "98",
                              "s" : [ {
                                 "r" : "97",
                                 "s" : [ {
                                    "value" : [ "T" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "98",
                                 "s" : [ {
                                    "value" : [ "system" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "99",
                              "s" : [ {
                                 "value" : [ "'fax'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "103",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "102",
                           "s" : [ {
                              "r" : "101",
                              "s" : [ {
                                 "value" : [ "T" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "102",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "104",
               "locator" : "75:3-77:16",
               "type" : "Query",
               "source" : [ {
                  "localId" : "96",
                  "locator" : "75:3-75:33",
                  "alias" : "T",
                  "expression" : {
                     "localId" : "95",
                     "locator" : "75:3-75:31",
                     "type" : "Flatten",
                     "operand" : {
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "name" : "Requesting Provider",
                              "type" : "ExpressionRef"
                           }
                        } ],
                        "where" : {
                           "type" : "Not",
                           "operand" : {
                              "type" : "IsNull",
                              "operand" : {
                                 "path" : "telecom",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        },
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "path" : "telecom",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "100",
                  "locator" : "76:3-76:24",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "98",
                     "locator" : "76:9-76:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "system",
                        "scope" : "T",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "99",
                     "locator" : "76:20-76:24",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "fax",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "103",
                  "locator" : "77:3-77:16",
                  "expression" : {
                     "localId" : "102",
                     "locator" : "77:10-77:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "value",
                        "scope" : "T",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "118",
            "locator" : "80:1-82:86",
            "name" : "Servicing Provider",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "118",
                  "s" : [ {
                     "value" : [ "","define ","\"Servicing Provider\"","://assuming the servicing provider is a lab - (molecular/genetic testing)\n   " ]
                  }, {
                     "r" : "117",
                     "s" : [ {
                        "value" : [ "singleton from " ]
                     }, {
                        "r" : "116",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "116",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "107",
                                 "s" : [ {
                                    "r" : "106",
                                    "s" : [ {
                                       "r" : "106",
                                       "s" : [ {
                                          "value" : [ "[","OrganizationProfile","]" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  " ]
                           }, {
                              "r" : "115",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "115",
                                 "s" : [ {
                                    "value" : [ "EndsWith","(" ]
                                 }, {
                                    "r" : "112",
                                    "s" : [ {
                                       "value" : [ "First","(" ]
                                    }, {
                                       "r" : "111",
                                       "s" : [ {
                                          "r" : "110",
                                          "s" : [ {
                                             "r" : "109",
                                             "s" : [ {
                                                "r" : "108",
                                                "s" : [ {
                                                   "value" : [ "\"Most Recent ServiceRequest\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "109",
                                                "s" : [ {
                                                   "value" : [ "performer" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "110",
                                             "s" : [ {
                                                "value" : [ "reference" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "111",
                                          "s" : [ {
                                             "value" : [ "value" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "114",
                                    "s" : [ {
                                       "r" : "113",
                                       "s" : [ {
                                          "value" : [ "O" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "114",
                                       "s" : [ {
                                          "value" : [ "id" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "117",
               "locator" : "81:4-82:86",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "116",
                  "locator" : "81:19-82:86",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "107",
                     "locator" : "81:20-81:42",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "106",
                        "locator" : "81:20-81:40",
                        "dataType" : "{http://hl7.org/fhir}Organization",
                        "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization",
                        "type" : "Retrieve"
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "115",
                     "locator" : "82:3-82:85",
                     "type" : "EndsWith",
                     "operand" : [ {
                        "localId" : "112",
                        "locator" : "82:18-82:78",
                        "type" : "First",
                        "source" : {
                           "localId" : "111",
                           "locator" : "82:24-82:77",
                           "type" : "Query",
                           "source" : [ {
                              "alias" : "$this",
                              "expression" : {
                                 "localId" : "110",
                                 "locator" : "82:24-82:71",
                                 "type" : "Query",
                                 "source" : [ {
                                    "alias" : "$this",
                                    "expression" : {
                                       "localId" : "109",
                                       "locator" : "82:24-82:61",
                                       "path" : "performer",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "108",
                                          "locator" : "82:24-82:51",
                                          "name" : "Most Recent ServiceRequest",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 } ],
                                 "where" : {
                                    "type" : "Not",
                                    "operand" : {
                                       "type" : "IsNull",
                                       "operand" : {
                                          "path" : "reference",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    }
                                 },
                                 "return" : {
                                    "distinct" : false,
                                    "expression" : {
                                       "path" : "reference",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 }
                              }
                           } ],
                           "where" : {
                              "type" : "Not",
                              "operand" : {
                                 "type" : "IsNull",
                                 "operand" : {
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           },
                           "return" : {
                              "distinct" : false,
                              "expression" : {
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        }
                     }, {
                        "localId" : "114",
                        "locator" : "82:81-82:84",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "id",
                           "scope" : "O",
                           "type" : "Property"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "121",
            "locator" : "84:1-85:29",
            "name" : "Servicing Provider Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "121",
                  "s" : [ {
                     "value" : [ "","define ","\"Servicing Provider Name\"",":\n    " ]
                  }, {
                     "r" : "120",
                     "s" : [ {
                        "r" : "119",
                        "s" : [ {
                           "value" : [ "\"Servicing Provider\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "120",
                        "s" : [ {
                           "value" : [ "name" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "120",
               "locator" : "85:5-85:29",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "name",
                  "type" : "Property",
                  "source" : {
                     "localId" : "119",
                     "locator" : "85:5-85:24",
                     "name" : "Servicing Provider",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "127",
            "locator" : "87:1-88:47",
            "name" : "Servicing Provider Phone",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "127",
                  "s" : [ {
                     "value" : [ "","define ","\"Servicing Provider Phone\"",":\n  " ]
                  }, {
                     "r" : "126",
                     "s" : [ {
                        "r" : "125",
                        "s" : [ {
                           "r" : "122",
                           "s" : [ {
                              "value" : [ "UC" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "125",
                           "s" : [ {
                              "value" : [ "Mobile","(" ]
                           }, {
                              "r" : "124",
                              "s" : [ {
                                 "r" : "123",
                                 "s" : [ {
                                    "value" : [ "\"Servicing Provider\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "124",
                                 "s" : [ {
                                    "value" : [ "telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "126",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "126",
               "locator" : "88:3-88:47",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "localId" : "125",
                     "locator" : "88:3-88:41",
                     "name" : "Mobile",
                     "libraryName" : "UC",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "124",
                        "locator" : "88:13-88:40",
                        "path" : "telecom",
                        "type" : "Property",
                        "source" : {
                           "localId" : "123",
                           "locator" : "88:13-88:32",
                           "name" : "Servicing Provider",
                           "type" : "ExpressionRef"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "138",
            "locator" : "95:1-98:16",
            "name" : "Servicing Provider NPI",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "138",
                  "s" : [ {
                     "value" : [ "// TODO: Error: Could not resolve data provider for package 'java.util'.\n/*\ndefine \"Servicing Provider Address\":\n  (singleton from \"Servicing Provider\".address).line\n*/\n","define ","\"Servicing Provider NPI\"",":\n  " ]
                  }, {
                     "r" : "137",
                     "s" : [ {
                        "s" : [ {
                           "r" : "129",
                           "s" : [ {
                              "r" : "128",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Servicing Provider\"",".","identifier" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","I" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " \n  " ]
                     }, {
                        "r" : "133",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "133",
                           "s" : [ {
                              "r" : "131",
                              "s" : [ {
                                 "r" : "130",
                                 "s" : [ {
                                    "value" : [ "I" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "131",
                                 "s" : [ {
                                    "value" : [ "system" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "132",
                              "s" : [ {
                                 "value" : [ "'http://hl7.org/fhir/sid/us-npi'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "136",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "135",
                           "s" : [ {
                              "r" : "134",
                              "s" : [ {
                                 "value" : [ "I" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "135",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "137",
               "locator" : "96:3-98:16",
               "type" : "Query",
               "source" : [ {
                  "localId" : "129",
                  "locator" : "96:3-96:35",
                  "alias" : "I",
                  "expression" : {
                     "localId" : "128",
                     "locator" : "96:3-96:33",
                     "path" : "identifier",
                     "type" : "Property",
                     "source" : {
                        "name" : "Servicing Provider",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "133",
                  "locator" : "97:3-97:51",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "131",
                     "locator" : "97:9-97:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "system",
                        "scope" : "I",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "132",
                     "locator" : "97:20-97:51",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "http://hl7.org/fhir/sid/us-npi",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "136",
                  "locator" : "98:3-98:16",
                  "expression" : {
                     "localId" : "135",
                     "locator" : "98:10-98:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "value",
                        "scope" : "I",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "149",
            "locator" : "100:1-103:16",
            "name" : "Servicing Provider Fax",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "149",
                  "s" : [ {
                     "value" : [ "","define ","\"Servicing Provider Fax\"",":\n  " ]
                  }, {
                     "r" : "148",
                     "s" : [ {
                        "s" : [ {
                           "r" : "140",
                           "s" : [ {
                              "r" : "139",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Servicing Provider\"",".","telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","T" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "144",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "144",
                           "s" : [ {
                              "r" : "142",
                              "s" : [ {
                                 "r" : "141",
                                 "s" : [ {
                                    "value" : [ "T" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "142",
                                 "s" : [ {
                                    "value" : [ "system" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "143",
                              "s" : [ {
                                 "value" : [ "'fax'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "147",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "146",
                           "s" : [ {
                              "r" : "145",
                              "s" : [ {
                                 "value" : [ "T" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "146",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "148",
               "locator" : "101:3-103:16",
               "type" : "Query",
               "source" : [ {
                  "localId" : "140",
                  "locator" : "101:3-101:32",
                  "alias" : "T",
                  "expression" : {
                     "localId" : "139",
                     "locator" : "101:3-101:30",
                     "path" : "telecom",
                     "type" : "Property",
                     "source" : {
                        "name" : "Servicing Provider",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "144",
                  "locator" : "102:3-102:24",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "142",
                     "locator" : "102:9-102:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "system",
                        "scope" : "T",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "143",
                     "locator" : "102:20-102:24",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "fax",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "147",
                  "locator" : "103:3-103:16",
                  "expression" : {
                     "localId" : "146",
                     "locator" : "103:10-103:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "value",
                        "scope" : "T",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "163",
            "locator" : "105:1-107:94",
            "name" : "Test Coverage",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "163",
                  "s" : [ {
                     "value" : [ "","define ","\"Test Coverage\"",":\n" ]
                  }, {
                     "r" : "162",
                     "s" : [ {
                        "s" : [ {
                           "r" : "151",
                           "s" : [ {
                              "r" : "150",
                              "s" : [ {
                                 "r" : "150",
                                 "s" : [ {
                                    "value" : [ "[","FHIR",".","Coverage","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n" ]
                     }, {
                        "r" : "161",
                        "s" : [ {
                           "value" : [ "with  " ]
                        }, {
                           "r" : "153",
                           "s" : [ {
                              "r" : "152",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Most Recent ServiceRequest\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","SR" ]
                           } ]
                        }, {
                           "value" : [ " such that  " ]
                        }, {
                           "r" : "160",
                           "s" : [ {
                              "value" : [ "EndsWith","(" ]
                           }, {
                              "r" : "157",
                              "s" : [ {
                                 "value" : [ "First","(" ]
                              }, {
                                 "r" : "156",
                                 "s" : [ {
                                    "r" : "155",
                                    "s" : [ {
                                       "r" : "154",
                                       "s" : [ {
                                          "value" : [ "SR" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "155",
                                       "s" : [ {
                                          "value" : [ "insurance" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "156",
                                    "s" : [ {
                                       "value" : [ "reference" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "159",
                              "s" : [ {
                                 "r" : "158",
                                 "s" : [ {
                                    "value" : [ "C" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "159",
                                 "s" : [ {
                                    "value" : [ "id" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "162",
               "locator" : "106:1-107:94",
               "type" : "Query",
               "source" : [ {
                  "localId" : "151",
                  "locator" : "106:1-106:17",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "150",
                     "locator" : "106:1-106:15",
                     "dataType" : "{http://hl7.org/fhir}Coverage",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Coverage",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ {
                  "localId" : "161",
                  "locator" : "107:1-107:94",
                  "alias" : "SR",
                  "type" : "With",
                  "expression" : {
                     "localId" : "152",
                     "locator" : "107:7-107:34",
                     "name" : "Most Recent ServiceRequest",
                     "type" : "ExpressionRef"
                  },
                  "suchThat" : {
                     "localId" : "160",
                     "locator" : "107:50-107:94",
                     "type" : "EndsWith",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "157",
                           "locator" : "107:59-107:87",
                           "type" : "First",
                           "source" : {
                              "localId" : "156",
                              "locator" : "107:65-107:86",
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "localId" : "155",
                                    "locator" : "107:65-107:76",
                                    "path" : "insurance",
                                    "scope" : "SR",
                                    "type" : "Property"
                                 }
                              } ],
                              "where" : {
                                 "type" : "Not",
                                 "operand" : {
                                    "type" : "IsNull",
                                    "operand" : {
                                       "path" : "reference",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 }
                              },
                              "return" : {
                                 "distinct" : false,
                                 "expression" : {
                                    "path" : "reference",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           }
                        } ]
                     }, {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "159",
                           "locator" : "107:90-107:93",
                           "path" : "id",
                           "scope" : "C",
                           "type" : "Property"
                        } ]
                     } ]
                  }
               } ]
            }
         }, {
            "localId" : "176",
            "locator" : "110:1-112:69",
            "name" : "Billing Provider",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "176",
                  "s" : [ {
                     "value" : [ "","define ","\"Billing Provider\"",":\n " ]
                  }, {
                     "r" : "175",
                     "s" : [ {
                        "value" : [ "singleton from" ]
                     }, {
                        "r" : "174",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "174",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "165",
                                 "s" : [ {
                                    "r" : "164",
                                    "s" : [ {
                                       "r" : "164",
                                       "s" : [ {
                                          "value" : [ "[","OrganizationProfile","]" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  " ]
                           }, {
                              "r" : "173",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "173",
                                 "s" : [ {
                                    "value" : [ "EndsWith","(" ]
                                 }, {
                                    "r" : "170",
                                    "s" : [ {
                                       "value" : [ "First","(" ]
                                    }, {
                                       "r" : "169",
                                       "s" : [ {
                                          "r" : "168",
                                          "s" : [ {
                                             "r" : "167",
                                             "s" : [ {
                                                "r" : "166",
                                                "s" : [ {
                                                   "value" : [ "\"Test Coverage\"" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "167",
                                                "s" : [ {
                                                   "value" : [ "payor" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "168",
                                             "s" : [ {
                                                "value" : [ "reference" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "169",
                                          "s" : [ {
                                             "value" : [ "value" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "172",
                                    "s" : [ {
                                       "r" : "171",
                                       "s" : [ {
                                          "value" : [ "O" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "172",
                                       "s" : [ {
                                          "value" : [ "id" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "175",
               "locator" : "111:2-112:69",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "174",
                  "locator" : "111:16-112:69",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "165",
                     "locator" : "111:17-111:39",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "164",
                        "locator" : "111:17-111:37",
                        "dataType" : "{http://hl7.org/fhir}Organization",
                        "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization",
                        "type" : "Retrieve"
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "173",
                     "locator" : "112:3-112:68",
                     "type" : "EndsWith",
                     "operand" : [ {
                        "localId" : "170",
                        "locator" : "112:18-112:61",
                        "type" : "First",
                        "source" : {
                           "localId" : "169",
                           "locator" : "112:24-112:60",
                           "type" : "Query",
                           "source" : [ {
                              "alias" : "$this",
                              "expression" : {
                                 "localId" : "168",
                                 "locator" : "112:24-112:54",
                                 "type" : "Query",
                                 "source" : [ {
                                    "alias" : "$this",
                                    "expression" : {
                                       "localId" : "167",
                                       "locator" : "112:24-112:44",
                                       "type" : "Flatten",
                                       "operand" : {
                                          "type" : "Query",
                                          "source" : [ {
                                             "alias" : "$this",
                                             "expression" : {
                                                "localId" : "166",
                                                "locator" : "112:24-112:38",
                                                "name" : "Test Coverage",
                                                "type" : "ExpressionRef"
                                             }
                                          } ],
                                          "where" : {
                                             "type" : "Not",
                                             "operand" : {
                                                "type" : "IsNull",
                                                "operand" : {
                                                   "path" : "payor",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "name" : "$this",
                                                      "type" : "AliasRef"
                                                   }
                                                }
                                             }
                                          },
                                          "return" : {
                                             "distinct" : false,
                                             "expression" : {
                                                "path" : "payor",
                                                "type" : "Property",
                                                "source" : {
                                                   "name" : "$this",
                                                   "type" : "AliasRef"
                                                }
                                             }
                                          }
                                       }
                                    }
                                 } ],
                                 "where" : {
                                    "type" : "Not",
                                    "operand" : {
                                       "type" : "IsNull",
                                       "operand" : {
                                          "path" : "reference",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    }
                                 },
                                 "return" : {
                                    "distinct" : false,
                                    "expression" : {
                                       "path" : "reference",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 }
                              }
                           } ],
                           "where" : {
                              "type" : "Not",
                              "operand" : {
                                 "type" : "IsNull",
                                 "operand" : {
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           },
                           "return" : {
                              "distinct" : false,
                              "expression" : {
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        }
                     }, {
                        "localId" : "172",
                        "locator" : "112:64-112:67",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "id",
                           "scope" : "O",
                           "type" : "Property"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "179",
            "locator" : "114:1-115:25",
            "name" : "Billing Provider Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "179",
                  "s" : [ {
                     "value" : [ "","define ","\"Billing Provider Name\"",":\n  " ]
                  }, {
                     "r" : "178",
                     "s" : [ {
                        "r" : "177",
                        "s" : [ {
                           "value" : [ "\"Billing Provider\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "178",
                        "s" : [ {
                           "value" : [ "name" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "178",
               "locator" : "115:3-115:25",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "name",
                  "type" : "Property",
                  "source" : {
                     "localId" : "177",
                     "locator" : "115:3-115:20",
                     "name" : "Billing Provider",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "185",
            "locator" : "117:1-118:45",
            "name" : "Billing Provider Phone",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "185",
                  "s" : [ {
                     "value" : [ "","define ","\"Billing Provider Phone\"",":\n  " ]
                  }, {
                     "r" : "184",
                     "s" : [ {
                        "r" : "183",
                        "s" : [ {
                           "r" : "180",
                           "s" : [ {
                              "value" : [ "UC" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "183",
                           "s" : [ {
                              "value" : [ "Mobile","(" ]
                           }, {
                              "r" : "182",
                              "s" : [ {
                                 "r" : "181",
                                 "s" : [ {
                                    "value" : [ "\"Billing Provider\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "182",
                                 "s" : [ {
                                    "value" : [ "telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "184",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "184",
               "locator" : "118:3-118:45",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "localId" : "183",
                     "locator" : "118:3-118:39",
                     "name" : "Mobile",
                     "libraryName" : "UC",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "182",
                        "locator" : "118:13-118:38",
                        "path" : "telecom",
                        "type" : "Property",
                        "source" : {
                           "localId" : "181",
                           "locator" : "118:13-118:30",
                           "name" : "Billing Provider",
                           "type" : "ExpressionRef"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "196",
            "locator" : "125:1-128:16",
            "name" : "Billing Provider NPI",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "196",
                  "s" : [ {
                     "value" : [ "// TODO: Error: Could not resolve data provider for package 'java.util'.\n/*\ndefine \"Billing Provider Address\":\n  (singleton from \"Billing Provider\".address).line\n*/\n","define ","\"Billing Provider NPI\"",":\n  " ]
                  }, {
                     "r" : "195",
                     "s" : [ {
                        "s" : [ {
                           "r" : "187",
                           "s" : [ {
                              "r" : "186",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Billing Provider\"",".","identifier" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","I" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " \n  " ]
                     }, {
                        "r" : "191",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "191",
                           "s" : [ {
                              "r" : "189",
                              "s" : [ {
                                 "r" : "188",
                                 "s" : [ {
                                    "value" : [ "I" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "189",
                                 "s" : [ {
                                    "value" : [ "system" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "190",
                              "s" : [ {
                                 "value" : [ "'http://hl7.org/fhir/sid/us-npi'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "194",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "193",
                           "s" : [ {
                              "r" : "192",
                              "s" : [ {
                                 "value" : [ "I" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "193",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "195",
               "locator" : "126:3-128:16",
               "type" : "Query",
               "source" : [ {
                  "localId" : "187",
                  "locator" : "126:3-126:33",
                  "alias" : "I",
                  "expression" : {
                     "localId" : "186",
                     "locator" : "126:3-126:31",
                     "path" : "identifier",
                     "type" : "Property",
                     "source" : {
                        "name" : "Billing Provider",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "191",
                  "locator" : "127:3-127:51",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "189",
                     "locator" : "127:9-127:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "system",
                        "scope" : "I",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "190",
                     "locator" : "127:20-127:51",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "http://hl7.org/fhir/sid/us-npi",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "194",
                  "locator" : "128:3-128:16",
                  "expression" : {
                     "localId" : "193",
                     "locator" : "128:10-128:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "value",
                        "scope" : "I",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "207",
            "locator" : "130:1-133:16",
            "name" : "Billing Provider Fax",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "207",
                  "s" : [ {
                     "value" : [ "","define ","\"Billing Provider Fax\"",":\n  " ]
                  }, {
                     "r" : "206",
                     "s" : [ {
                        "s" : [ {
                           "r" : "198",
                           "s" : [ {
                              "r" : "197",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Billing Provider\"",".","telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","T" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "202",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "202",
                           "s" : [ {
                              "r" : "200",
                              "s" : [ {
                                 "r" : "199",
                                 "s" : [ {
                                    "value" : [ "T" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "200",
                                 "s" : [ {
                                    "value" : [ "system" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "201",
                              "s" : [ {
                                 "value" : [ "'fax'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "205",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "204",
                           "s" : [ {
                              "r" : "203",
                              "s" : [ {
                                 "value" : [ "T" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "204",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "206",
               "locator" : "131:3-133:16",
               "type" : "Query",
               "source" : [ {
                  "localId" : "198",
                  "locator" : "131:3-131:30",
                  "alias" : "T",
                  "expression" : {
                     "localId" : "197",
                     "locator" : "131:3-131:28",
                     "path" : "telecom",
                     "type" : "Property",
                     "source" : {
                        "name" : "Billing Provider",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "202",
                  "locator" : "132:3-132:24",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "200",
                     "locator" : "132:9-132:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "system",
                        "scope" : "T",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "201",
                     "locator" : "132:20-132:24",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "fax",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "205",
                  "locator" : "133:3-133:16",
                  "expression" : {
                     "localId" : "204",
                     "locator" : "133:10-133:16",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "value",
                        "scope" : "T",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "211",
            "locator" : "141:1-142:47",
            "name" : "Date of Service",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "211",
                  "s" : [ {
                     "value" : [ "","define ","\"Date of Service\"",":\n  " ]
                  }, {
                     "r" : "210",
                     "s" : [ {
                        "r" : "209",
                        "s" : [ {
                           "r" : "208",
                           "s" : [ {
                              "value" : [ "\"Most Recent ServiceRequest\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "209",
                           "s" : [ {
                              "value" : [ "occurrence" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "210",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "210",
               "locator" : "142:3-142:47",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "209",
                  "locator" : "142:3-142:41",
                  "path" : "occurrence",
                  "type" : "Property",
                  "source" : {
                     "localId" : "208",
                     "locator" : "142:3-142:30",
                     "name" : "Most Recent ServiceRequest",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "218",
            "locator" : "144:1-146:16",
            "name" : "Requested Test",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "","define ","\"Requested Test\"",":\n  " ]
                  }, {
                     "r" : "217",
                     "s" : [ {
                        "s" : [ {
                           "r" : "213",
                           "s" : [ {
                              "r" : "212",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Most Recent ServiceRequest\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","SR" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "216",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "215",
                           "s" : [ {
                              "r" : "214",
                              "s" : [ {
                                 "value" : [ "SR" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "215",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "217",
               "locator" : "145:3-146:16",
               "type" : "Query",
               "source" : [ {
                  "localId" : "213",
                  "locator" : "145:3-145:33",
                  "alias" : "SR",
                  "expression" : {
                     "localId" : "212",
                     "locator" : "145:3-145:30",
                     "name" : "Most Recent ServiceRequest",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "216",
                  "locator" : "146:3-146:16",
                  "expression" : {
                     "localId" : "215",
                     "locator" : "146:10-146:16",
                     "path" : "code",
                     "scope" : "SR",
                     "type" : "Property"
                  }
               }
            }
         }, {
            "localId" : "223",
            "locator" : "148:1-149:36",
            "name" : "Test ID",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "223",
                  "s" : [ {
                     "value" : [ "","define ","\"Test ID\"",":\n  " ]
                  }, {
                     "r" : "222",
                     "s" : [ {
                        "r" : "221",
                        "s" : [ {
                           "r" : "220",
                           "s" : [ {
                              "r" : "219",
                              "s" : [ {
                                 "value" : [ "\"Requested Test\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "220",
                              "s" : [ {
                                 "value" : [ "coding" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "221",
                           "s" : [ {
                              "value" : [ "code" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "222",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "222",
               "locator" : "149:3-149:36",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "221",
                     "locator" : "149:3-149:30",
                     "type" : "Query",
                     "source" : [ {
                        "alias" : "$this",
                        "expression" : {
                           "localId" : "220",
                           "locator" : "149:3-149:25",
                           "path" : "coding",
                           "type" : "Property",
                           "source" : {
                              "localId" : "219",
                              "locator" : "149:3-149:18",
                              "name" : "Requested Test",
                              "type" : "ExpressionRef"
                           }
                        }
                     } ],
                     "where" : {
                        "type" : "Not",
                        "operand" : {
                           "type" : "IsNull",
                           "operand" : {
                              "path" : "code",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     },
                     "return" : {
                        "distinct" : false,
                        "expression" : {
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        }
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "name" : "$this",
                        "type" : "AliasRef"
                     }
                  }
               }
            }
         }, {
            "localId" : "228",
            "locator" : "151:1-152:40",
            "name" : "Test name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "228",
                  "s" : [ {
                     "value" : [ "","define ","\"Test name\"",":\n   " ]
                  }, {
                     "r" : "227",
                     "s" : [ {
                        "r" : "226",
                        "s" : [ {
                           "r" : "225",
                           "s" : [ {
                              "r" : "224",
                              "s" : [ {
                                 "value" : [ "\"Requested Test\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "225",
                              "s" : [ {
                                 "value" : [ "coding" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "226",
                           "s" : [ {
                              "value" : [ "display" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "227",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "227",
               "locator" : "152:4-152:40",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "226",
                     "locator" : "152:4-152:34",
                     "type" : "Query",
                     "source" : [ {
                        "alias" : "$this",
                        "expression" : {
                           "localId" : "225",
                           "locator" : "152:4-152:26",
                           "path" : "coding",
                           "type" : "Property",
                           "source" : {
                              "localId" : "224",
                              "locator" : "152:4-152:19",
                              "name" : "Requested Test",
                              "type" : "ExpressionRef"
                           }
                        }
                     } ],
                     "where" : {
                        "type" : "Not",
                        "operand" : {
                           "type" : "IsNull",
                           "operand" : {
                              "path" : "display",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     },
                     "return" : {
                        "distinct" : false,
                        "expression" : {
                           "path" : "display",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        }
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "name" : "$this",
                        "type" : "AliasRef"
                     }
                  }
               }
            }
         }, {
            "localId" : "239",
            "locator" : "157:1-160:10",
            "name" : "Test ICD Codes",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "239",
                  "s" : [ {
                     "value" : [ "","define ","\"Test ICD Codes\"",":\n " ]
                  }, {
                     "r" : "238",
                     "s" : [ {
                        "s" : [ {
                           "r" : "230",
                           "s" : [ {
                              "r" : "229",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Requested Test\"",".","coding" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "235",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "235",
                           "s" : [ {
                              "r" : "233",
                              "s" : [ {
                                 "r" : "232",
                                 "s" : [ {
                                    "r" : "231",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "232",
                                    "s" : [ {
                                       "value" : [ "system" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "233",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","=","  " ]
                           }, {
                              "r" : "234",
                              "s" : [ {
                                 "value" : [ "'http://hl7.org/fhir/sid/icd-10-cm'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "237",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "236",
                           "s" : [ {
                              "value" : [ "C" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "238",
               "locator" : "158:2-160:10",
               "type" : "Query",
               "source" : [ {
                  "localId" : "230",
                  "locator" : "158:2-158:26",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "229",
                     "locator" : "158:2-158:24",
                     "path" : "coding",
                     "type" : "Property",
                     "source" : {
                        "name" : "Requested Test",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "235",
                  "locator" : "159:3-159:61",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "233",
                     "locator" : "159:9-159:22",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "232",
                        "locator" : "159:9-159:16",
                        "path" : "system",
                        "scope" : "C",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "234",
                     "locator" : "159:27-159:61",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "http://hl7.org/fhir/sid/icd-10-cm",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "237",
                  "locator" : "160:3-160:10",
                  "expression" : {
                     "localId" : "236",
                     "locator" : "160:10",
                     "name" : "C",
                     "type" : "AliasRef"
                  }
               }
            }
         }, {
            "localId" : "251",
            "locator" : "162:1-165:10",
            "name" : "Test CPT Codes",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "251",
                  "s" : [ {
                     "value" : [ "","define ","\"Test CPT Codes\"",":\n  " ]
                  }, {
                     "r" : "250",
                     "s" : [ {
                        "s" : [ {
                           "r" : "242",
                           "s" : [ {
                              "r" : "241",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Requested Test\"",".","coding" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "247",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "247",
                           "s" : [ {
                              "r" : "245",
                              "s" : [ {
                                 "r" : "244",
                                 "s" : [ {
                                    "r" : "243",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "244",
                                    "s" : [ {
                                       "value" : [ "system" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "245",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","=","  " ]
                           }, {
                              "r" : "246",
                              "s" : [ {
                                 "value" : [ "'http://www.ama-assn.org/go/cpt'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "249",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "248",
                           "s" : [ {
                              "value" : [ "C" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "250",
               "locator" : "163:3-165:10",
               "type" : "Query",
               "source" : [ {
                  "localId" : "242",
                  "locator" : "163:3-163:27",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "241",
                     "locator" : "163:3-163:25",
                     "path" : "coding",
                     "type" : "Property",
                     "source" : {
                        "name" : "Requested Test",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "247",
                  "locator" : "164:3-164:58",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "245",
                     "locator" : "164:9-164:22",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "244",
                        "locator" : "164:9-164:16",
                        "path" : "system",
                        "scope" : "C",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "246",
                     "locator" : "164:27-164:58",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "http://www.ama-assn.org/go/cpt",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "249",
                  "locator" : "165:3-165:10",
                  "expression" : {
                     "localId" : "248",
                     "locator" : "165:10",
                     "name" : "C",
                     "type" : "AliasRef"
                  }
               }
            }
         }, {
            "localId" : "257",
            "locator" : "154:1-155:63",
            "name" : "ALL ICD and CPT Test Codes",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "257",
                  "s" : [ {
                     "value" : [ "","define ","\"ALL ICD and CPT Test Codes\"",":\n   " ]
                  }, {
                     "r" : "256",
                     "s" : [ {
                        "r" : "240",
                        "s" : [ {
                           "value" : [ "\"Test ICD Codes\"" ]
                        } ]
                     }, {
                        "value" : [ " union " ]
                     }, {
                        "r" : "255",
                        "s" : [ {
                           "r" : "252",
                           "s" : [ {
                              "value" : [ "\"Test CPT Codes\"" ]
                           } ]
                        }, {
                           "value" : [ " as " ]
                        }, {
                           "r" : "254",
                           "s" : [ {
                              "value" : [ "List<" ]
                           }, {
                              "r" : "253",
                              "s" : [ {
                                 "value" : [ "FHIR",".","Coding" ]
                              } ]
                           }, {
                              "value" : [ ">" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "256",
               "locator" : "155:4-155:63",
               "type" : "Union",
               "operand" : [ {
                  "localId" : "240",
                  "locator" : "155:4-155:19",
                  "name" : "Test ICD Codes",
                  "type" : "ExpressionRef"
               }, {
                  "localId" : "255",
                  "locator" : "155:27-155:63",
                  "strict" : false,
                  "type" : "As",
                  "operand" : {
                     "localId" : "252",
                     "locator" : "155:27-155:42",
                     "name" : "Test CPT Codes",
                     "type" : "ExpressionRef"
                  },
                  "asTypeSpecifier" : {
                     "localId" : "254",
                     "locator" : "155:47-155:63",
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "localId" : "253",
                        "locator" : "155:52-155:62",
                        "name" : "{http://hl7.org/fhir}Coding",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               } ]
            }
         }, {
            "localId" : "269",
            "locator" : "167:1-169:91",
            "name" : "Test Related Condition",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "269",
                  "s" : [ {
                     "value" : [ "","define ","\"Test Related Condition\"",":\n  " ]
                  }, {
                     "r" : "268",
                     "s" : [ {
                        "s" : [ {
                           "r" : "259",
                           "s" : [ {
                              "r" : "258",
                              "s" : [ {
                                 "r" : "258",
                                 "s" : [ {
                                    "value" : [ "[","FHIR",".","Condition","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "267",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "267",
                           "s" : [ {
                              "value" : [ "EndsWith","(" ]
                           }, {
                              "r" : "264",
                              "s" : [ {
                                 "value" : [ "First","(" ]
                              }, {
                                 "r" : "263",
                                 "s" : [ {
                                    "r" : "262",
                                    "s" : [ {
                                       "r" : "261",
                                       "s" : [ {
                                          "r" : "260",
                                          "s" : [ {
                                             "value" : [ "\"Most Recent ServiceRequest\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "261",
                                          "s" : [ {
                                             "value" : [ "reasonReference" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "262",
                                       "s" : [ {
                                          "value" : [ "reference" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "263",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "266",
                              "s" : [ {
                                 "r" : "265",
                                 "s" : [ {
                                    "value" : [ "C" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "266",
                                 "s" : [ {
                                    "value" : [ "id" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "268",
               "locator" : "168:3-169:91",
               "type" : "Query",
               "source" : [ {
                  "localId" : "259",
                  "locator" : "168:3-168:20",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "258",
                     "locator" : "168:3-168:18",
                     "dataType" : "{http://hl7.org/fhir}Condition",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Condition",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "267",
                  "locator" : "169:3-169:91",
                  "type" : "EndsWith",
                  "operand" : [ {
                     "localId" : "264",
                     "locator" : "169:18-169:84",
                     "type" : "First",
                     "source" : {
                        "localId" : "263",
                        "locator" : "169:24-169:83",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "localId" : "262",
                              "locator" : "169:24-169:77",
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "localId" : "261",
                                    "locator" : "169:24-169:67",
                                    "path" : "reasonReference",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "260",
                                       "locator" : "169:24-169:51",
                                       "name" : "Most Recent ServiceRequest",
                                       "type" : "ExpressionRef"
                                    }
                                 }
                              } ],
                              "where" : {
                                 "type" : "Not",
                                 "operand" : {
                                    "type" : "IsNull",
                                    "operand" : {
                                       "path" : "reference",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 }
                              },
                              "return" : {
                                 "distinct" : false,
                                 "expression" : {
                                    "path" : "reference",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           }
                        } ],
                        "where" : {
                           "type" : "Not",
                           "operand" : {
                              "type" : "IsNull",
                              "operand" : {
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        },
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     }
                  }, {
                     "name" : "ToString",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "266",
                        "locator" : "169:87-169:90",
                        "path" : "id",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "275",
            "locator" : "172:1-173:52",
            "name" : "Diagnosis Descriptions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "275",
                  "s" : [ {
                     "value" : [ "//.reasonReference changed to .reason in FHIR R5\n","define ","\"Diagnosis Descriptions\"",":\n  " ]
                  }, {
                     "r" : "274",
                     "s" : [ {
                        "r" : "273",
                        "s" : [ {
                           "r" : "272",
                           "s" : [ {
                              "r" : "271",
                              "s" : [ {
                                 "r" : "270",
                                 "s" : [ {
                                    "value" : [ "\"Test Related Condition\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "271",
                                 "s" : [ {
                                    "value" : [ "code" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "272",
                              "s" : [ {
                                 "value" : [ "coding" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "273",
                           "s" : [ {
                              "value" : [ "display" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "274",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "274",
               "locator" : "173:3-173:52",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "273",
                     "locator" : "173:3-173:46",
                     "type" : "Query",
                     "source" : [ {
                        "alias" : "$this",
                        "expression" : {
                           "localId" : "272",
                           "locator" : "173:3-173:38",
                           "type" : "Flatten",
                           "operand" : {
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "localId" : "271",
                                    "locator" : "173:3-173:31",
                                    "type" : "Query",
                                    "source" : [ {
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "270",
                                          "locator" : "173:3-173:26",
                                          "name" : "Test Related Condition",
                                          "type" : "ExpressionRef"
                                       }
                                    } ],
                                    "where" : {
                                       "type" : "Not",
                                       "operand" : {
                                          "type" : "IsNull",
                                          "operand" : {
                                             "path" : "code",
                                             "type" : "Property",
                                             "source" : {
                                                "name" : "$this",
                                                "type" : "AliasRef"
                                             }
                                          }
                                       }
                                    },
                                    "return" : {
                                       "distinct" : false,
                                       "expression" : {
                                          "path" : "code",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    }
                                 }
                              } ],
                              "where" : {
                                 "type" : "Not",
                                 "operand" : {
                                    "type" : "IsNull",
                                    "operand" : {
                                       "path" : "coding",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 }
                              },
                              "return" : {
                                 "distinct" : false,
                                 "expression" : {
                                    "path" : "coding",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           }
                        }
                     } ],
                     "where" : {
                        "type" : "Not",
                        "operand" : {
                           "type" : "IsNull",
                           "operand" : {
                              "path" : "display",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     },
                     "return" : {
                        "distinct" : false,
                        "expression" : {
                           "path" : "display",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        }
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "name" : "$this",
                        "type" : "AliasRef"
                     }
                  }
               }
            }
         }, {
            "localId" : "284",
            "locator" : "175:1-179:6",
            "name" : "Billing Provider different from Servicing Provider",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "284",
                  "s" : [ {
                     "value" : [ "","define ","\"Billing Provider different from Servicing Provider\"",":\n  " ]
                  }, {
                     "r" : "283",
                     "s" : [ {
                        "value" : [ "if " ]
                     }, {
                        "r" : "280",
                        "s" : [ {
                           "r" : "277",
                           "s" : [ {
                              "r" : "276",
                              "s" : [ {
                                 "value" : [ "\"Billing Provider\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "277",
                              "s" : [ {
                                 "value" : [ "id" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","!="," " ]
                        }, {
                           "r" : "279",
                           "s" : [ {
                              "r" : "278",
                              "s" : [ {
                                 "value" : [ "\"Servicing Provider\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "279",
                              "s" : [ {
                                 "value" : [ "id" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " then\n  " ]
                     }, {
                        "r" : "281",
                        "s" : [ {
                           "value" : [ "'Yes'" ]
                        } ]
                     }, {
                        "value" : [ "\n  else \n  " ]
                     }, {
                        "r" : "282",
                        "s" : [ {
                           "value" : [ "'No'" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "283",
               "locator" : "176:3-179:6",
               "type" : "If",
               "condition" : {
                  "localId" : "280",
                  "locator" : "176:6-176:53",
                  "type" : "Not",
                  "operand" : {
                     "locator" : "176:6-176:53",
                     "type" : "Equal",
                     "operand" : [ {
                        "localId" : "277",
                        "locator" : "176:6-176:26",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "id",
                           "type" : "Property",
                           "source" : {
                              "localId" : "276",
                              "locator" : "176:6-176:23",
                              "name" : "Billing Provider",
                              "type" : "ExpressionRef"
                           }
                        }
                     }, {
                        "localId" : "279",
                        "locator" : "176:31-176:53",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "id",
                           "type" : "Property",
                           "source" : {
                              "localId" : "278",
                              "locator" : "176:31-176:50",
                              "name" : "Servicing Provider",
                              "type" : "ExpressionRef"
                           }
                        }
                     } ]
                  }
               },
               "then" : {
                  "localId" : "281",
                  "locator" : "177:3-177:7",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "Yes",
                  "type" : "Literal"
               },
               "else" : {
                  "localId" : "282",
                  "locator" : "179:3-179:6",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "No",
                  "type" : "Literal"
               }
            }
         }, {
            "localId" : "298",
            "locator" : "198:1-200:56",
            "name" : "Research Subject",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "298",
                  "s" : [ {
                     "value" : [ "","define ","\"Research Subject\"",":\n     " ]
                  }, {
                     "r" : "297",
                     "s" : [ {
                        "s" : [ {
                           "r" : "290",
                           "s" : [ {
                              "r" : "289",
                              "s" : [ {
                                 "r" : "289",
                                 "s" : [ {
                                    "value" : [ "[","FHIR",".","ResearchSubject","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","R" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n     " ]
                     }, {
                        "r" : "296",
                        "s" : [ {
                           "value" : [ "where  " ]
                        }, {
                           "r" : "296",
                           "s" : [ {
                              "value" : [ "EndsWith","(" ]
                           }, {
                              "r" : "293",
                              "s" : [ {
                                 "r" : "292",
                                 "s" : [ {
                                    "r" : "291",
                                    "s" : [ {
                                       "value" : [ "R" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "292",
                                    "s" : [ {
                                       "value" : [ "individual" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "293",
                                 "s" : [ {
                                    "value" : [ "reference" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "295",
                              "s" : [ {
                                 "r" : "294",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "295",
                                 "s" : [ {
                                    "value" : [ "id" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "297",
               "locator" : "199:6-200:56",
               "type" : "Query",
               "source" : [ {
                  "localId" : "290",
                  "locator" : "199:6-199:29",
                  "alias" : "R",
                  "expression" : {
                     "localId" : "289",
                     "locator" : "199:6-199:27",
                     "dataType" : "{http://hl7.org/fhir}ResearchSubject",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/ResearchSubject",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "296",
                  "locator" : "200:6-200:56",
                  "type" : "EndsWith",
                  "operand" : [ {
                     "name" : "ToString",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "293",
                        "locator" : "200:22-200:43",
                        "path" : "reference",
                        "type" : "Property",
                        "source" : {
                           "localId" : "292",
                           "locator" : "200:22-200:33",
                           "path" : "individual",
                           "scope" : "R",
                           "type" : "Property"
                        }
                     } ]
                  }, {
                     "localId" : "295",
                     "locator" : "200:46-200:55",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "id",
                        "type" : "Property",
                        "source" : {
                           "localId" : "294",
                           "locator" : "200:46-200:52",
                           "name" : "Patient",
                           "type" : "ExpressionRef"
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "317",
            "locator" : "205:1-208:66",
            "name" : "Clinical Trial",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "317",
                  "s" : [ {
                     "value" : [ "","define ","\"Clinical Trial\"",":\n  " ]
                  }, {
                     "r" : "316",
                     "s" : [ {
                        "s" : [ {
                           "r" : "288",
                           "s" : [ {
                              "r" : "287",
                              "s" : [ {
                                 "r" : "287",
                                 "s" : [ {
                                    "value" : [ "[","FHIR",".","ResearchStudy","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","R" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " \n  " ]
                     }, {
                        "r" : "307",
                        "s" : [ {
                           "value" : [ "with " ]
                        }, {
                           "r" : "300",
                           "s" : [ {
                              "r" : "299",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Research Subject\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","S" ]
                           } ]
                        }, {
                           "value" : [ " such that " ]
                        }, {
                           "r" : "306",
                           "s" : [ {
                              "value" : [ "EndsWith","(" ]
                           }, {
                              "r" : "303",
                              "s" : [ {
                                 "r" : "302",
                                 "s" : [ {
                                    "r" : "301",
                                    "s" : [ {
                                       "value" : [ "S" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "302",
                                    "s" : [ {
                                       "value" : [ "study" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "303",
                                 "s" : [ {
                                    "value" : [ "reference" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "305",
                              "s" : [ {
                                 "r" : "304",
                                 "s" : [ {
                                    "value" : [ "R" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "305",
                                 "s" : [ {
                                    "value" : [ "id" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "315",
                        "s" : [ {
                           "value" : [ "with  " ]
                        }, {
                           "r" : "309",
                           "s" : [ {
                              "r" : "308",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Test Related Condition\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        }, {
                           "value" : [ " such that " ]
                        }, {
                           "r" : "314",
                           "s" : [ {
                              "r" : "311",
                              "s" : [ {
                                 "r" : "310",
                                 "s" : [ {
                                    "value" : [ "C" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "311",
                                 "s" : [ {
                                    "value" : [ "code" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "313",
                              "s" : [ {
                                 "r" : "312",
                                 "s" : [ {
                                    "value" : [ "R" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "313",
                                 "s" : [ {
                                    "value" : [ "condition" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "316",
               "locator" : "206:3-208:66",
               "type" : "Query",
               "source" : [ {
                  "localId" : "288",
                  "locator" : "206:3-206:24",
                  "alias" : "R",
                  "expression" : {
                     "localId" : "287",
                     "locator" : "206:3-206:22",
                     "dataType" : "{http://hl7.org/fhir}ResearchStudy",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/ResearchStudy",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ {
                  "localId" : "307",
                  "locator" : "207:3-207:71",
                  "alias" : "S",
                  "type" : "With",
                  "expression" : {
                     "localId" : "299",
                     "locator" : "207:8-207:25",
                     "name" : "Research Subject",
                     "type" : "ExpressionRef"
                  },
                  "suchThat" : {
                     "localId" : "306",
                     "locator" : "207:39-207:71",
                     "type" : "EndsWith",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "303",
                           "locator" : "207:48-207:64",
                           "path" : "reference",
                           "type" : "Property",
                           "source" : {
                              "localId" : "302",
                              "locator" : "207:48-207:54",
                              "path" : "study",
                              "scope" : "S",
                              "type" : "Property"
                           }
                        } ]
                     }, {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "305",
                           "locator" : "207:67-207:70",
                           "path" : "id",
                           "scope" : "R",
                           "type" : "Property"
                        } ]
                     } ]
                  }
               }, {
                  "localId" : "315",
                  "locator" : "208:3-208:66",
                  "alias" : "C",
                  "type" : "With",
                  "expression" : {
                     "localId" : "308",
                     "locator" : "208:9-208:32",
                     "name" : "Test Related Condition",
                     "type" : "ExpressionRef"
                  },
                  "suchThat" : {
                     "localId" : "314",
                     "locator" : "208:46-208:66",
                     "type" : "In",
                     "operand" : [ {
                        "localId" : "311",
                        "locator" : "208:46-208:51",
                        "path" : "code",
                        "scope" : "C",
                        "type" : "Property"
                     }, {
                        "localId" : "313",
                        "locator" : "208:56-208:66",
                        "path" : "condition",
                        "scope" : "R",
                        "type" : "Property"
                     } ]
                  }
               } ]
            }
         }, {
            "localId" : "329",
            "locator" : "181:1-183:72",
            "name" : "Clinical Trial Organization",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "329",
                  "s" : [ {
                     "value" : [ "","define ","\"Clinical Trial Organization\"",":\n  " ]
                  }, {
                     "r" : "328",
                     "s" : [ {
                        "value" : [ "First","(" ]
                     }, {
                        "r" : "327",
                        "s" : [ {
                           "s" : [ {
                              "r" : "286",
                              "s" : [ {
                                 "r" : "285",
                                 "s" : [ {
                                    "r" : "285",
                                    "s" : [ {
                                       "value" : [ "[","OrganizationProfile","]" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","O" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n " ]
                        }, {
                           "r" : "326",
                           "s" : [ {
                              "value" : [ "with " ]
                           }, {
                              "r" : "319",
                              "s" : [ {
                                 "r" : "318",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "\"Clinical Trial\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "  ","T" ]
                              } ]
                           }, {
                              "value" : [ " such that " ]
                           }, {
                              "r" : "325",
                              "s" : [ {
                                 "value" : [ "EndsWith","(" ]
                              }, {
                                 "r" : "322",
                                 "s" : [ {
                                    "r" : "321",
                                    "s" : [ {
                                       "r" : "320",
                                       "s" : [ {
                                          "value" : [ "T" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "321",
                                       "s" : [ {
                                          "value" : [ "sponsor" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "322",
                                    "s" : [ {
                                       "value" : [ "reference" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "324",
                                 "s" : [ {
                                    "r" : "323",
                                    "s" : [ {
                                       "value" : [ "O" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "324",
                                    "s" : [ {
                                       "value" : [ "id" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ ")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "328",
               "locator" : "182:3-183:72",
               "type" : "First",
               "source" : {
                  "localId" : "327",
                  "locator" : "182:9-183:71",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "286",
                     "locator" : "182:9-182:31",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "285",
                        "locator" : "182:9-182:29",
                        "dataType" : "{http://hl7.org/fhir}Organization",
                        "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization",
                        "type" : "Retrieve"
                     }
                  } ],
                  "relationship" : [ {
                     "localId" : "326",
                     "locator" : "183:2-183:71",
                     "alias" : "T",
                     "type" : "With",
                     "expression" : {
                        "localId" : "318",
                        "locator" : "183:7-183:22",
                        "name" : "Clinical Trial",
                        "type" : "ExpressionRef"
                     },
                     "suchThat" : {
                        "localId" : "325",
                        "locator" : "183:37-183:71",
                        "type" : "EndsWith",
                        "operand" : [ {
                           "name" : "ToString",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "322",
                              "locator" : "183:46-183:64",
                              "path" : "reference",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "321",
                                 "locator" : "183:46-183:54",
                                 "path" : "sponsor",
                                 "scope" : "T",
                                 "type" : "Property"
                              }
                           } ]
                        }, {
                           "localId" : "324",
                           "locator" : "183:67-183:70",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "id",
                              "scope" : "O",
                              "type" : "Property"
                           }
                        } ]
                     }
                  } ]
               }
            }
         }, {
            "localId" : "333",
            "locator" : "185:1-186:52",
            "name" : "BillingProvider is Clinical Trial Organisation",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "333",
                  "s" : [ {
                     "value" : [ "//in FHIR R5 T.associatedParty instead of T.sponsor\n","define ","\"BillingProvider is Clinical Trial Organisation\"",":\n  " ]
                  }, {
                     "r" : "332",
                     "s" : [ {
                        "r" : "330",
                        "s" : [ {
                           "value" : [ "\"Billing Provider\"" ]
                        } ]
                     }, {
                        "value" : [ " ","="," " ]
                     }, {
                        "r" : "331",
                        "s" : [ {
                           "value" : [ "\"Clinical Trial Organization\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "332",
               "locator" : "186:3-186:52",
               "type" : "Equal",
               "operand" : [ {
                  "localId" : "330",
                  "locator" : "186:3-186:20",
                  "name" : "Billing Provider",
                  "type" : "ExpressionRef"
               }, {
                  "localId" : "331",
                  "locator" : "186:24-186:52",
                  "name" : "Clinical Trial Organization",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "336",
            "locator" : "195:1-196:28",
            "name" : "Is Research Subject",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "336",
                  "s" : [ {
                     "value" : [ "","define ","\"Is Research Subject\"",":\n  " ]
                  }, {
                     "r" : "335",
                     "s" : [ {
                        "value" : [ "exists" ]
                     }, {
                        "r" : "334",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "334",
                           "s" : [ {
                              "value" : [ "\"Research Subject\"" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "335",
               "locator" : "196:3-196:28",
               "type" : "Exists",
               "operand" : {
                  "localId" : "334",
                  "locator" : "196:9-196:28",
                  "name" : "Research Subject",
                  "type" : "ExpressionRef"
               }
            }
         }, {
            "localId" : "343",
            "locator" : "189:1-193:5",
            "name" : "Part of clinical trial",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "343",
                  "s" : [ {
                     "value" : [ "//TODO does not get populated properly\n","define ","\"Part of clinical trial\"",":\n " ]
                  }, {
                     "r" : "342",
                     "s" : [ {
                        "value" : [ "if " ]
                     }, {
                        "r" : "339",
                        "s" : [ {
                           "r" : "337",
                           "s" : [ {
                              "value" : [ "\"Is Research Subject\"" ]
                           } ]
                        }, {
                           "value" : [ " and " ]
                        }, {
                           "r" : "338",
                           "s" : [ {
                              "value" : [ "\"BillingProvider is Clinical Trial Organisation\"" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " then\n " ]
                     }, {
                        "r" : "340",
                        "s" : [ {
                           "value" : [ "'Yes'" ]
                        } ]
                     }, {
                        "value" : [ "\n else\n " ]
                     }, {
                        "r" : "341",
                        "s" : [ {
                           "value" : [ "'No'" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "342",
               "locator" : "190:2-193:5",
               "type" : "If",
               "condition" : {
                  "localId" : "339",
                  "locator" : "190:5-190:78",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "337",
                     "locator" : "190:5-190:25",
                     "name" : "Is Research Subject",
                     "type" : "ExpressionRef"
                  }, {
                     "localId" : "338",
                     "locator" : "190:31-190:78",
                     "name" : "BillingProvider is Clinical Trial Organisation",
                     "type" : "ExpressionRef"
                  } ]
               },
               "then" : {
                  "localId" : "340",
                  "locator" : "191:2-191:6",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "Yes",
                  "type" : "Literal"
               },
               "else" : {
                  "localId" : "341",
                  "locator" : "193:2-193:5",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "No",
                  "type" : "Literal"
               }
            }
         }, {
            "localId" : "347",
            "locator" : "202:1-203:22",
            "name" : "All clinical Trials",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "347",
                  "s" : [ {
                     "value" : [ "//ResearchSubject.individual is from FHIR version v4.0.1 and has been replaced by R.subject in FHIR R5\n","define ","\"All clinical Trials\"",":\n" ]
                  }, {
                     "r" : "346",
                     "s" : [ {
                        "s" : [ {
                           "r" : "345",
                           "s" : [ {
                              "r" : "344",
                              "s" : [ {
                                 "r" : "344",
                                 "s" : [ {
                                    "value" : [ "[","FHIR",".","ResearchStudy","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","R" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "346",
               "locator" : "203:1-203:22",
               "type" : "Query",
               "source" : [ {
                  "localId" : "345",
                  "locator" : "203:1-203:22",
                  "alias" : "R",
                  "expression" : {
                     "localId" : "344",
                     "locator" : "203:1-203:20",
                     "dataType" : "{http://hl7.org/fhir}ResearchStudy",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/ResearchStudy",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ ]
            }
         }, {
            "localId" : "359",
            "locator" : "210:1-213:22",
            "name" : "Clinical Trial ID",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "359",
                  "s" : [ {
                     "value" : [ "","define ","\"Clinical Trial ID\"",":\n  " ]
                  }, {
                     "r" : "358",
                     "s" : [ {
                        "s" : [ {
                           "r" : "349",
                           "s" : [ {
                              "r" : "348",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Clinical Trial\"",".","identifier" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "353",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "353",
                           "s" : [ {
                              "r" : "351",
                              "s" : [ {
                                 "r" : "350",
                                 "s" : [ {
                                    "value" : [ "C" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "351",
                                 "s" : [ {
                                    "value" : [ "system" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "352",
                              "s" : [ {
                                 "value" : [ "'https://clinicaltrials.gov'" ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "357",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "356",
                           "s" : [ {
                              "r" : "355",
                              "s" : [ {
                                 "r" : "354",
                                 "s" : [ {
                                    "value" : [ "C" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "355",
                                 "s" : [ {
                                    "value" : [ "value" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "356",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "358",
               "locator" : "211:3-213:22",
               "type" : "Query",
               "source" : [ {
                  "localId" : "349",
                  "locator" : "211:3-211:31",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "348",
                     "locator" : "211:3-211:29",
                     "type" : "Flatten",
                     "operand" : {
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "name" : "Clinical Trial",
                              "type" : "ExpressionRef"
                           }
                        } ],
                        "where" : {
                           "type" : "Not",
                           "operand" : {
                              "type" : "IsNull",
                              "operand" : {
                                 "path" : "identifier",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "$this",
                                    "type" : "AliasRef"
                                 }
                              }
                           }
                        },
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "path" : "identifier",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     }
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "353",
                  "locator" : "212:3-212:47",
                  "type" : "Equal",
                  "operand" : [ {
                     "name" : "ToString",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "351",
                        "locator" : "212:9-212:16",
                        "path" : "system",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  }, {
                     "localId" : "352",
                     "locator" : "212:20-212:47",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "https://clinicaltrials.gov",
                     "type" : "Literal"
                  } ]
               },
               "return" : {
                  "localId" : "357",
                  "locator" : "213:3-213:22",
                  "expression" : {
                     "localId" : "356",
                     "locator" : "213:10-213:22",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "355",
                        "locator" : "213:10-213:16",
                        "path" : "value",
                        "scope" : "C",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "376",
            "locator" : "216:1-219:10",
            "name" : "GetServiceRequestReasonCondition",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "376",
                  "s" : [ {
                     "value" : [ "","define function ","\"GetServiceRequestReasonCondition\"","(","S"," " ]
                  }, {
                     "r" : "360",
                     "s" : [ {
                        "value" : [ "ServiceRequest" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "375",
                     "s" : [ {
                        "r" : "375",
                        "s" : [ {
                           "s" : [ {
                              "r" : "362",
                              "s" : [ {
                                 "r" : "361",
                                 "s" : [ {
                                    "r" : "361",
                                    "s" : [ {
                                       "value" : [ "[","FHIR",".","Condition","]" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","C" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  " ]
                        }, {
                           "r" : "372",
                           "s" : [ {
                              "value" : [ "with  " ]
                           }, {
                              "r" : "364",
                              "s" : [ {
                                 "r" : "363",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "\"Most Recent ServiceRequest\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","SR" ]
                              } ]
                           }, {
                              "value" : [ " such that  " ]
                           }, {
                              "r" : "371",
                              "s" : [ {
                                 "value" : [ "EndsWith","(" ]
                              }, {
                                 "r" : "368",
                                 "s" : [ {
                                    "value" : [ "First","(" ]
                                 }, {
                                    "r" : "367",
                                    "s" : [ {
                                       "r" : "366",
                                       "s" : [ {
                                          "r" : "365",
                                          "s" : [ {
                                             "value" : [ "SR" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "366",
                                          "s" : [ {
                                             "value" : [ "insurance" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "367",
                                       "s" : [ {
                                          "value" : [ "reference" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "370",
                                 "s" : [ {
                                    "r" : "369",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "370",
                                    "s" : [ {
                                       "value" : [ "id" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  " ]
                        }, {
                           "r" : "374",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "373",
                              "s" : [ {
                                 "value" : [ "C" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "375",
               "locator" : "217:3-219:10",
               "type" : "Query",
               "source" : [ {
                  "localId" : "362",
                  "locator" : "217:3-217:20",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "361",
                     "locator" : "217:3-217:18",
                     "dataType" : "{http://hl7.org/fhir}Condition",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/Condition",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ {
                  "localId" : "372",
                  "locator" : "218:3-218:96",
                  "alias" : "SR",
                  "type" : "With",
                  "expression" : {
                     "localId" : "363",
                     "locator" : "218:9-218:36",
                     "name" : "Most Recent ServiceRequest",
                     "type" : "ExpressionRef"
                  },
                  "suchThat" : {
                     "localId" : "371",
                     "locator" : "218:52-218:96",
                     "type" : "EndsWith",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "368",
                           "locator" : "218:61-218:89",
                           "type" : "First",
                           "source" : {
                              "localId" : "367",
                              "locator" : "218:67-218:88",
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "localId" : "366",
                                    "locator" : "218:67-218:78",
                                    "path" : "insurance",
                                    "scope" : "SR",
                                    "type" : "Property"
                                 }
                              } ],
                              "where" : {
                                 "type" : "Not",
                                 "operand" : {
                                    "type" : "IsNull",
                                    "operand" : {
                                       "path" : "reference",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 }
                              },
                              "return" : {
                                 "distinct" : false,
                                 "expression" : {
                                    "path" : "reference",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           }
                        } ]
                     }, {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "370",
                           "locator" : "218:92-218:95",
                           "path" : "id",
                           "scope" : "C",
                           "type" : "Property"
                        } ]
                     } ]
                  }
               } ],
               "return" : {
                  "localId" : "374",
                  "locator" : "219:3-219:10",
                  "expression" : {
                     "localId" : "373",
                     "locator" : "219:10",
                     "name" : "C",
                     "type" : "AliasRef"
                  }
               }
            },
            "operand" : [ {
               "name" : "S",
               "operandTypeSpecifier" : {
                  "localId" : "360",
                  "locator" : "216:54-216:67",
                  "name" : "{http://hl7.org/fhir}ServiceRequest",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "403",
            "locator" : "222:1-228:19",
            "name" : "Previous genetic testing for condition",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "403",
                  "s" : [ {
                     "value" : [ "","define ","\"Previous genetic testing for condition\"",":\n   " ]
                  }, {
                     "r" : "402",
                     "s" : [ {
                        "s" : [ {
                           "value" : [ "from " ]
                        }, {
                           "r" : "378",
                           "s" : [ {
                              "r" : "377",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All ServiceRequests\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","S" ]
                           } ]
                        }, {
                           "value" : [ ",\n   " ]
                        }, {
                           "r" : "380",
                           "s" : [ {
                              "r" : "379",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Most Recent ServiceRequest\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","SR" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " \n   " ]
                     }, {
                        "r" : "397",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "397",
                           "s" : [ {
                              "r" : "391",
                              "s" : [ {
                                 "r" : "385",
                                 "s" : [ {
                                    "r" : "382",
                                    "s" : [ {
                                       "r" : "381",
                                       "s" : [ {
                                          "value" : [ "S" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "382",
                                       "s" : [ {
                                          "value" : [ "occurrence" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "385",
                                    "value" : [ " ","before"," " ]
                                 }, {
                                    "r" : "384",
                                    "s" : [ {
                                       "r" : "383",
                                       "s" : [ {
                                          "value" : [ "SR" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "384",
                                       "s" : [ {
                                          "value" : [ "occurrence" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n   and " ]
                              }, {
                                 "r" : "390",
                                 "s" : [ {
                                    "r" : "387",
                                    "s" : [ {
                                       "r" : "386",
                                       "s" : [ {
                                          "value" : [ "S" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "387",
                                       "s" : [ {
                                          "value" : [ "id" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","!="," " ]
                                 }, {
                                    "r" : "389",
                                    "s" : [ {
                                       "r" : "388",
                                       "s" : [ {
                                          "value" : [ "SR" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "389",
                                       "s" : [ {
                                          "value" : [ "id" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n   and " ]
                           }, {
                              "r" : "396",
                              "s" : [ {
                                 "r" : "393",
                                 "s" : [ {
                                    "r" : "392",
                                    "s" : [ {
                                       "value" : [ "S" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "393",
                                    "s" : [ {
                                       "value" : [ "reasonReference" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "395",
                                 "s" : [ {
                                    "r" : "394",
                                    "s" : [ {
                                       "value" : [ "SR" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "395",
                                    "s" : [ {
                                       "value" : [ "reasonReference" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  " ]
                     }, {
                        "r" : "401",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "400",
                           "s" : [ {
                              "r" : "399",
                              "s" : [ {
                                 "r" : "398",
                                 "s" : [ {
                                    "value" : [ "S" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "399",
                                 "s" : [ {
                                    "value" : [ "id" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "400",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "402",
               "locator" : "223:4-228:19",
               "type" : "Query",
               "source" : [ {
                  "localId" : "378",
                  "locator" : "223:9-223:31",
                  "alias" : "S",
                  "expression" : {
                     "localId" : "377",
                     "locator" : "223:9-223:29",
                     "name" : "All ServiceRequests",
                     "type" : "ExpressionRef"
                  }
               }, {
                  "localId" : "380",
                  "locator" : "224:4-224:34",
                  "alias" : "SR",
                  "expression" : {
                     "localId" : "379",
                     "locator" : "224:4-224:31",
                     "name" : "Most Recent ServiceRequest",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "397",
                  "locator" : "225:4-227:45",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "391",
                     "locator" : "225:10-226:20",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "385",
                        "locator" : "225:10-225:42",
                        "type" : "Before",
                        "operand" : [ {
                           "name" : "ToDateTime",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "asType" : "{http://hl7.org/fhir}dateTime",
                              "type" : "As",
                              "operand" : {
                                 "localId" : "382",
                                 "locator" : "225:10-225:21",
                                 "path" : "occurrence",
                                 "scope" : "S",
                                 "type" : "Property"
                              }
                           } ]
                        }, {
                           "name" : "ToDateTime",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "asType" : "{http://hl7.org/fhir}dateTime",
                              "type" : "As",
                              "operand" : {
                                 "localId" : "384",
                                 "locator" : "225:30-225:42",
                                 "path" : "occurrence",
                                 "scope" : "SR",
                                 "type" : "Property"
                              }
                           } ]
                        } ]
                     }, {
                        "localId" : "390",
                        "locator" : "226:8-226:20",
                        "type" : "Not",
                        "operand" : {
                           "locator" : "226:8-226:20",
                           "type" : "Equal",
                           "operand" : [ {
                              "localId" : "387",
                              "locator" : "226:8-226:11",
                              "path" : "id",
                              "scope" : "S",
                              "type" : "Property"
                           }, {
                              "localId" : "389",
                              "locator" : "226:16-226:20",
                              "path" : "id",
                              "scope" : "SR",
                              "type" : "Property"
                           } ]
                        }
                     } ]
                  }, {
                     "localId" : "396",
                     "locator" : "227:8-227:45",
                     "type" : "Equal",
                     "operand" : [ {
                        "localId" : "393",
                        "locator" : "227:8-227:24",
                        "path" : "reasonReference",
                        "scope" : "S",
                        "type" : "Property"
                     }, {
                        "localId" : "395",
                        "locator" : "227:28-227:45",
                        "path" : "reasonReference",
                        "scope" : "SR",
                        "type" : "Property"
                     } ]
                  } ]
               },
               "return" : {
                  "localId" : "401",
                  "locator" : "228:3-228:19",
                  "expression" : {
                     "localId" : "400",
                     "locator" : "228:10-228:19",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "399",
                        "locator" : "228:10-228:13",
                        "path" : "id",
                        "scope" : "S",
                        "type" : "Property"
                     }
                  }
               }
            }
         } ]
      }
   }
}" + } ] +} \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-MBODAInitialExpressions.json b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-MBODAInitialExpressions.json new file mode 100644 index 000000000..3c6595c49 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-MBODAInitialExpressions.json @@ -0,0 +1,470 @@ +{ + "resourceType": "Library", + "id": "MBODAInitialExpressions", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/cqf/us/common/Library/MBODAInitialExpressions", + "version": "0.1.0", + "name": "MBODAInitialExpressions", + "relatedArtifact": [ { + "type": "depends-on", + "display": "USCore model information", + "resource": "http://hl7.org/fhir/Library/USCore-ModelInfo" + }, { + "type": "depends-on", + "display": "FHIR model information", + "resource": "http://fhir.org/guides/cqf/common/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Library UC", + "resource": "http://fhir.org/guides/cqf/us/common/Library/USCoreCommon|0.1.0" + }, { + "type": "depends-on", + "display": "Library UCE", + "resource": "http://fhir.org/guides/cqf/us/common/Library/USCoreElements|0.1.0" + }, { + "type": "depends-on", + "display": "Library CMD", + "resource": "http://fhir.org/guides/cqf/us/common/Library/CumulativeMedicationDuration|3.1.000" + }, { + "type": "depends-on", + "display": "Library UC", + "resource": "http://fhir.org/guides/cqf/us/common/Library/USCoreCommon|0.1.0" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, { + "type": "depends-on", + "display": "Code system IdentifierType", + "resource": "http://terminology.hl7.org/CodeSystem/v2-0203" + }, { + "type": "depends-on", + "display": "Code system AllergyIntoleranceVerificationStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-verification" + }, { + "type": "depends-on", + "display": "Code system AllergyIntoleranceClinicalStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical" + }, { + "type": "depends-on", + "display": "Code system ObservationStatusCodes", + "resource": "http://hl7.org/fhir/observation-status" + } ], + "parameter": [ { + "name": "ErrorLevel", + "use": "in", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Member ID", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Patient Name", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Last Name", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Date of Birth", + "use": "out", + "min": 0, + "max": "1", + "type": "date" + }, { + "name": "Medical Record Number", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Phone Number", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Allergies", + "use": "out", + "min": 0, + "max": "*", + "type": "CodeableConcept" + }, { + "name": "Address", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "City", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "State", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Zip", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Height", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Height in [in_i]", + "use": "out", + "min": 0, + "max": "1", + "type": "decimal" + }, { + "name": "Weight", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Weight in [lb_av]", + "use": "out", + "min": 0, + "max": "1", + "type": "decimal" + }, { + "name": "Most Recent BSA", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Calculated BSA - Mosteller", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "BSA", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "BSA in m2", + "use": "out", + "min": 0, + "max": "1", + "type": "decimal" + }, { + "name": "Height in cm", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Weight in kg", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Calculated BSA - DuBois and DuBois", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Birth Sex", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Diagnosis Codes", + "use": "out", + "min": 0, + "max": "*", + "type": "CodeableConcept" + }, { + "name": "Diagnosis Descriptions", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Most Recent Medication Request", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Medication Requested", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Medication Name", + "use": "out", + "min": 0, + "max": "*", + "type": "string" + }, { + "name": "Code of Requested Drug", + "use": "out", + "min": 0, + "max": "*", + "type": "CodeableConcept" + }, { + "name": "Medication Request References", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Most Recent Medication Request dosageInstruction", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Most Recent Medication Request dosageInstruction.doseAndRate", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Medication Dose", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Medication Route", + "use": "out", + "min": 0, + "max": "1", + "type": "CodeableConcept" + }, { + "name": "Medication Frequency value", + "use": "out", + "min": 0, + "max": "1", + "type": "integer" + }, { + "name": "Medication Frequency Period", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Medication Frequency", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Quantity or Number of requested Visits", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Prior Prescription", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "New therapy", + "use": "out", + "min": 0, + "max": "1", + "type": "boolean" + }, { + "name": "New therapy code", + "use": "out", + "min": 0, + "max": "1", + "type": "Coding" + }, { + "name": "Initial date of therapy", + "use": "out", + "min": 0, + "max": "*", + "type": "dateTime" + }, { + "name": "Medication Request Period", + "use": "out", + "min": 0, + "max": "1", + "type": "Period" + }, { + "name": "Expected Therapy Length", + "use": "out", + "min": 0, + "max": "1", + "type": "Quantity" + }, { + "name": "Anticipated/actual date of service", + "use": "out", + "min": 0, + "max": "1", + "type": "date" + } ], + "dataRequirement": [ { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "Coverage", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Coverage" ], + "mustSupport": [ "subscriber", "subscriber.reference", "subscriberId", "subscriberId.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "value", "value.value", "type", "type.codes" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "value", "value.value", "type", "type.codes" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ], + "mustSupport": [ "code" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "city", "city.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "state", "state.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "postalCode", "postalCode.value" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyheight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyweight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/Observation" ], + "mustSupport": [ "code", "status" ], + "codeFilter": [ { + "path": "code", + "code": [ { + "system": "http://loinc.org", + "code": "8277-6", + "display": "Intensive care unit" + } ] + } ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "url", "value.value" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ], + "mustSupport": [ "code", "codes" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ], + "mustSupport": [ "code", "codes" ] + }, { + "type": "MedicationRequest", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest" ] + }, { + "type": "Medication", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" ] + }, { + "type": "Medication", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" ], + "mustSupport": [ "id", "id.value", "code", "code.display" ] + }, { + "type": "Medication", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" ], + "mustSupport": [ "id", "id.value", "code", "code.display" ] + }, { + "type": "Medication", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" ], + "mustSupport": [ "id", "id.value", "code", "code.display" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "library MBODAInitialExpressions version '0.1.0'

using USCore version '3.1.1'
using FHIR version '4.0.1'

include FHIRHelpers version '4.1.000'
include USCoreCommon version '0.1.0' called UC
include USCoreElements version '0.1.0' called UCE

//CumulativeMedicationDuration was created as part of the US ECQM and CDC Opioid Guideline development 
//http://fhir.org/guides/cdc/opioid-mme-r4
include CumulativeMedicationDuration version '3.1.000' called CMD

codesystem "LOINC": 'http://loinc.org'
code "Body surface area": '8277-6' from "LOINC" display 'Intensive care unit'

context Patient

define "Member ID":
  singleton from (
    [FHIR.Coverage] C
    where EndsWith(C.subscriber.reference, Patient.id)
    return C.subscriberId.value
  )

define "Patient Name":
  UCE."Name - First Middle(s) Last"

define "Last Name":
  UCE."Last Name"

// TODO: Error: Could not resolve data provider for package 'java.util'.
// define "First Name":
//   Patient.name.given.first()

define "Date of Birth":
  Patient.birthDate
  
define "Medical Record Number":
  singleton from 
  (
    (Patient.identifier I
      return {value: I.value, type: I.type.codes.code}
    ) valueByTypes
    // TODO: create code for MR (medical record number)
    where UC."MedicalRecordNumber".code in valueByTypes.type
    return valueByTypes.value
  )

define "Phone Number":
  UC.Mobile(Patient.telecom).value

define "Allergies":
  UCE."Active Confirmed Allergies and Intolerances" A
    return A.code

// TODO: Error: Could not resolve data provider for package 'java.util'.
// define "Address":
//   (singleton from Patient.address).line
define "Address":
  { 'TODO: remove hard-coded address' }

define "City":
  Patient.address.city

define "State":
  Patient.address.state

define "Zip":
  Patient.address.postalCode

define "Height":
  convert(
    UC.MostRecent(
      UCE."All Body Height Measurements".resulted()
    ).value 
  ) to '[in_i]'

define "Height in [in_i]":
  "Height".value

define "Weight":
  convert(
    UC.MostRecent(
      UCE."All Body Weight Measurements".resulted()
    ).value 
  ) to '[lb_av]'

define "Weight in [lb_av]":
  "Weight".value

define "Most Recent BSA":
  convert( 
    UC.MostRecent(
      ([FHIR.Observation: "Body surface area"] observation
        where observation.status ~ UC."observation-final".code
          or observation.status ~ UC."observation-amended".code
          or observation.status ~ UC."observation-corrected".code
      )
    ).value 
  ) to 'm2'

define "BSA":
  Coalesce("Most Recent BSA", "Calculated BSA - Mosteller")

define "BSA in m2":
  "BSA".value

// Mosteller formula using lbs and inches
define "Calculated BSA - Mosteller":
  CalculateBSA('Mosteller', "Height", "Weight")
  //((("Weight"*"Height")/3131).value)^0.5

define "Height in cm":
  convert("Height") to 'cm'

define "Weight in kg":
  convert("Weight") to 'kg'

define "Calculated BSA - DuBois and DuBois":
  CalculateBSA('DuBois and DuBois', "Height", "Weight")

define function CalculateBSA(alg System.String, height System.Quantity, weight System.Quantity):
  System.Quantity { value: 
    // Mosteller formula using lbs and inches
    if (alg = 'Mosteller') then
      ((((convert(height) to '[in_i]') * (convert(weight) to '[lb_av]'))/3131).value)^0.5
    
    // DuBois and DuBois formula using cm and kg
    // NOTE: never to be used for newborn calculation
    else if (alg = 'DuBois and DuBois') then
      0.007184 * ((convert(height) to 'cm').value^0.725) * ((convert(weight) to 'kg').value^0.425)
    
    // No matching algorithm found
    else null,
    unit: 'm2'
  }

// QUESTION: do we want to use Patient.gender as a backup? If so we'll need a ConceptMap or translation
define "Birth Sex":
 Patient.birthsex

define "Diagnosis Codes":
  UCE."All Conditions" C
    return C.code

define "Diagnosis Descriptions":
  "Diagnosis Codes" ConceptItem
    return Combine(((ConceptItem.codes) C return C.display), '|')

define "Medication Requested":
  UCE."All Medications" M
    where EndsWith(("Most Recent Medication Request".medication as USCore.Reference).reference, M.id)

define "Medication Name":
  "Medication Requested" M
    return M.code.display

define "Code of Requested Drug":
  "Medication Requested" M
    return M.code

define "Most Recent Medication Request":
  UCE."Most Recent Medication Request"

define "Medication Request References":
  ("Most Recent Medication Request".medication as USCore.Reference).reference

define "Most Recent Medication Request dosageInstruction":
  // TODO: should this really be a singleton?
  singleton from "Most Recent Medication Request".dosageInstruction

define "Most Recent Medication Request dosageInstruction.doseAndRate":
  // TODO: should this really be a singleton?
  singleton from "Most Recent Medication Request dosageInstruction".doseAndRate

define "Medication Dose":
  "Most Recent Medication Request dosageInstruction.doseAndRate".dose

define "Medication Route":
  "Most Recent Medication Request dosageInstruction".route

define "Medication Frequency value":
  "Most Recent Medication Request dosageInstruction".timing.repeat.frequency

define "Medication Frequency Period":
  if (IsNull("Most Recent Medication Request dosageInstruction".timing.repeat.period)) then 
    null
  else
    System.Quantity {
      value: "Most Recent Medication Request dosageInstruction".timing.repeat.period,
      unit: "Most Recent Medication Request dosageInstruction".timing.repeat.periodUnit
    }

define "Medication Frequency": // '1x per 1d', '3x per 2wk', '1x per 1mo'
  ToString("Medication Frequency value") + 'x' +
  ' per ' + ToString("Medication Frequency Period".value) + 
  ' ' + "Medication Frequency Period".unit

define "Quantity or Number of requested Visits":
  "Most Recent Medication Request".dispenseRequest.quantity

define "Prior Prescription":
  "Most Recent Medication Request".priorPrescription

define "New therapy":
  IsNull("Prior Prescription")

define "New therapy code":
  if ("New therapy") then
    System.Code { code: 'NewMedication', display: 'New Medication' }
  else
    System.Code { code: 'ContinuedTherapy', display: 'Continuation of therapy' }

// MISSING: needs test data to validate
//Initial date of therapy does not return correct result if there have been more than 1 prior Prescriptions - logic needs to be adapted to that case
define "Initial date of therapy":
  if not "New therapy" then
    UCE."All Medication Requests" M
      where EndsWith(("Most Recent Medication Request".priorPrescription as USCore.Reference).reference, M.id)
      return M.authoredOn
  else 
    null

define "Medication Request Period":
  CMD."MedicationRequestPeriod"("Most Recent Medication Request")

define "Expected Therapy Length":
  convert(
    CMD.Quantity(days between start of "Medication Request Period" and end of "Medication Request Period", 'd')
  ) to 'd'

define "Anticipated/actual date of service":
  start of "Medication Request Period"

/*
//related Procedures - Procedure is not linked to medication request - not possible to find the related procedures
*/" + }, { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1">
   <annotation translatorVersion="2.7.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="367">
         <a:s>library MBODAInitialExpressions version '0.1.0'</a:s>
      </a:s>
   </annotation>
   <identifier id="MBODAInitialExpressions" system="http://fhir.org/guides/cqf/us/common" version="0.1.0"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="3:1-3:28" localIdentifier="USCore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="1">
               <a:s>using </a:s>
               <a:s>
                  <a:s>USCore</a:s>
               </a:s>
               <a:s> version '3.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="2" locator="4:1-4:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1">
         <annotation xsi:type="a:Annotation">
            <a:s r="2">
               <a:s>using </a:s>
               <a:s>
                  <a:s>FHIR</a:s>
               </a:s>
               <a:s> version '4.0.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="3" locator="6:1-6:37" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/cqf/us/common/FHIRHelpers" version="4.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="3">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.1.000'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="4" locator="7:1-7:46" localIdentifier="UC" path="http://fhir.org/guides/cqf/us/common/USCoreCommon" version="0.1.0">
         <annotation xsi:type="a:Annotation">
            <a:s r="4">
               <a:s>include </a:s>
               <a:s>
                  <a:s>USCoreCommon</a:s>
               </a:s>
               <a:s> version '0.1.0' called UC</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="5" locator="8:1-8:49" localIdentifier="UCE" path="http://fhir.org/guides/cqf/us/common/USCoreElements" version="0.1.0">
         <annotation xsi:type="a:Annotation">
            <a:s r="5">
               <a:s>include </a:s>
               <a:s>
                  <a:s>USCoreElements</a:s>
               </a:s>
               <a:s> version '0.1.0' called UCE</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="6" locator="12:1-12:65" localIdentifier="CMD" path="http://fhir.org/guides/cqf/us/common/CumulativeMedicationDuration" version="3.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="6">
               <a:s>//CumulativeMedicationDuration was created as part of the US ECQM and CDC Opioid Guideline development 
//http://fhir.org/guides/cdc/opioid-mme-r4
include </a:s>
               <a:s>
                  <a:s>CumulativeMedicationDuration</a:s>
               </a:s>
               <a:s> version '3.1.000' called CMD</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <codeSystems>
      <def localId="7" locator="14:1-14:38" name="LOINC" id="http://loinc.org" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="7">
               <a:s>codesystem &quot;LOINC&quot;: 'http://loinc.org'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <codes>
      <def localId="9" locator="15:1-15:77" name="Body surface area" id="8277-6" display="Intensive care unit" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="9">
               <a:s>code &quot;Body surface area&quot;: '8277-6' from </a:s>
               <a:s r="8">
                  <a:s>&quot;LOINC&quot;</a:s>
               </a:s>
               <a:s> display 'Intensive care unit'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="8" locator="15:41-15:47" name="LOINC"/>
      </def>
   </codes>
   <contexts>
      <def locator="17:1-17:15" name="Patient"/>
   </contexts>
   <statements>
      <def locator="17:1-17:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="17:1-17:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="24" locator="19:1-24:3" name="Member ID" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="24">
               <a:s>define &quot;Member ID&quot;:
  </a:s>
               <a:s r="23">
                  <a:s>singleton from </a:s>
                  <a:s r="22">
                     <a:s>(
    </a:s>
                     <a:s r="22">
                        <a:s>
                           <a:s r="11">
                              <a:s r="10">
                                 <a:s r="10">
                                    <a:s>[FHIR.Coverage]</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> C</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    </a:s>
                        <a:s r="17">
                           <a:s>where </a:s>
                           <a:s r="17">
                              <a:s>EndsWith(</a:s>
                              <a:s r="14">
                                 <a:s r="13">
                                    <a:s r="12">
                                       <a:s>C</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="13">
                                       <a:s>subscriber</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="14">
                                    <a:s>reference</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="16">
                                 <a:s r="15">
                                    <a:s>Patient</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="16">
                                    <a:s>id</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    </a:s>
                        <a:s r="21">
                           <a:s>return </a:s>
                           <a:s r="20">
                              <a:s r="19">
                                 <a:s r="18">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="19">
                                    <a:s>subscriberId</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="20">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="23" locator="20:3-24:3" xsi:type="SingletonFrom">
            <operand localId="22" locator="20:18-24:3" xsi:type="Query">
               <source localId="11" locator="21:5-21:21" alias="C">
                  <expression localId="10" locator="21:5-21:19" dataType="fhir:Coverage" templateId="http://hl7.org/fhir/StructureDefinition/Coverage" xsi:type="Retrieve"/>
               </source>
               <where localId="17" locator="22:5-22:54" xsi:type="EndsWith">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand localId="14" locator="22:20-22:41" path="reference" xsi:type="Property">
                        <source localId="13" locator="22:20-22:31" path="subscriber" scope="C" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand localId="16" locator="22:44-22:53" path="value" xsi:type="Property">
                     <source path="id" xsi:type="Property">
                        <source localId="15" locator="22:44-22:50" name="Patient" xsi:type="ExpressionRef"/>
                     </source>
                  </operand>
               </where>
               <return localId="21" locator="23:5-23:31">
                  <expression localId="20" locator="23:12-23:31" path="value" xsi:type="Property">
                     <source localId="19" locator="23:12-23:25" path="subscriberId" scope="C" xsi:type="Property"/>
                  </expression>
               </return>
            </operand>
         </expression>
      </def>
      <def localId="27" locator="26:1-27:35" name="Patient Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="27">
               <a:s>define &quot;Patient Name&quot;:
  </a:s>
               <a:s r="26">
                  <a:s r="25">
                     <a:s>UCE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="26">
                     <a:s>&quot;Name - First Middle(s) Last&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="26" locator="27:3-27:35" name="Name - First Middle(s) Last" libraryName="UCE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="30" locator="29:1-30:17" name="Last Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="30">
               <a:s>define &quot;Last Name&quot;:
  </a:s>
               <a:s r="29">
                  <a:s r="28">
                     <a:s>UCE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="29">
                     <a:s>&quot;Last Name&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="29" locator="30:3-30:17" name="Last Name" libraryName="UCE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="33" locator="36:1-37:19" name="Date of Birth" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="33">
               <a:s>// TODO: Error: Could not resolve data provider for package 'java.util'.
// define &quot;First Name&quot;:
//   Patient.name.given.first()
define &quot;Date of Birth&quot;:
  </a:s>
               <a:s r="32">
                  <a:s r="31">
                     <a:s>Patient</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="32">
                     <a:s>birthDate</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="32" locator="37:3-37:19" path="value" xsi:type="Property">
            <source path="birthDate" xsi:type="Property">
               <source localId="31" locator="37:3-37:9" name="Patient" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="57" locator="39:1-48:3" name="Medical Record Number" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="57">
               <a:s>define &quot;Medical Record Number&quot;:
  </a:s>
               <a:s r="56">
                  <a:s>singleton from 
  </a:s>
                  <a:s r="55">
                     <a:s>(
    </a:s>
                     <a:s r="55">
                        <a:s>
                           <a:s r="45">
                              <a:s r="44">
                                 <a:s>(</a:s>
                                 <a:s r="44">
                                    <a:s>
                                       <a:s r="35">
                                          <a:s r="34">
                                             <a:s>
                                                <a:s>Patient.identifier</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> I</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
      </a:s>
                                    <a:s r="43">
                                       <a:s>return </a:s>
                                       <a:s r="42">
                                          <a:s>{</a:s>
                                          <a:s>
                                             <a:s>value: </a:s>
                                             <a:s r="37">
                                                <a:s r="36">
                                                   <a:s>I</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="37">
                                                   <a:s>value</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>, </a:s>
                                          <a:s>
                                             <a:s>type: </a:s>
                                             <a:s r="41">
                                                <a:s r="40">
                                                   <a:s r="39">
                                                      <a:s r="38">
                                                         <a:s>I</a:s>
                                                      </a:s>
                                                      <a:s>.</a:s>
                                                      <a:s r="39">
                                                         <a:s>type</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="40">
                                                      <a:s>codes</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="41">
                                                   <a:s>code</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>}</a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
    )</a:s>
                              </a:s>
                              <a:s> valueByTypes</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    // TODO: create code for MR (medical record number)
    </a:s>
                        <a:s r="51">
                           <a:s>where </a:s>
                           <a:s r="51">
                              <a:s r="48">
                                 <a:s r="47">
                                    <a:s r="46">
                                       <a:s>UC</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="47">
                                       <a:s>&quot;MedicalRecordNumber&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="48">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> in </a:s>
                              <a:s r="50">
                                 <a:s r="49">
                                    <a:s>valueByTypes</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="50">
                                    <a:s>type</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    </a:s>
                        <a:s r="54">
                           <a:s>return </a:s>
                           <a:s r="53">
                              <a:s r="52">
                                 <a:s>valueByTypes</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="53">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="56" locator="40:3-48:3" xsi:type="SingletonFrom">
            <operand localId="55" locator="41:3-48:3" xsi:type="Query">
               <source localId="45" locator="42:5-44:18" alias="valueByTypes">
                  <expression localId="44" locator="42:5-44:5" xsi:type="Query">
                     <source localId="35" locator="42:6-42:25" alias="I">
                        <expression localId="34" locator="42:6-42:23" path="identifier" xsi:type="Property">
                           <source name="Patient" xsi:type="ExpressionRef"/>
                        </expression>
                     </source>
                     <return localId="43" locator="43:7-43:54">
                        <expression localId="42" locator="43:14-43:54" xsi:type="Tuple">
                           <element name="value">
                              <value localId="37" locator="43:22-43:28" path="value" xsi:type="Property">
                                 <source path="value" scope="I" xsi:type="Property"/>
                              </value>
                           </element>
                           <element name="type">
                              <value localId="41" locator="43:37-43:53" xsi:type="Query">
                                 <source alias="$this">
                                    <expression localId="40" locator="43:37-43:48" path="codes" xsi:type="Property">
                                       <source localId="39" locator="43:37-43:42" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="type" scope="I" xsi:type="Property"/>
                                       </source>
                                    </expression>
                                 </source>
                                 <where xsi:type="Not">
                                    <operand xsi:type="IsNull">
                                       <operand path="code" xsi:type="Property">
                                          <source name="$this" xsi:type="AliasRef"/>
                                       </operand>
                                    </operand>
                                 </where>
                                 <return distinct="false">
                                    <expression path="code" xsi:type="Property">
                                       <source name="$this" xsi:type="AliasRef"/>
                                    </expression>
                                 </return>
                              </value>
                           </element>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="51" locator="46:5-46:60" xsi:type="In">
                  <operand localId="48" locator="46:11-46:39" path="code" xsi:type="Property">
                     <source localId="47" locator="46:11-46:34" name="MedicalRecordNumber" libraryName="UC" xsi:type="CodeRef"/>
                  </operand>
                  <operand localId="50" locator="46:44-46:60" path="type" scope="valueByTypes" xsi:type="Property"/>
               </where>
               <return localId="54" locator="47:5-47:29">
                  <expression localId="53" locator="47:12-47:29" path="value" scope="valueByTypes" xsi:type="Property"/>
               </return>
            </operand>
         </expression>
      </def>
      <def localId="63" locator="50:1-51:34" name="Phone Number" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="63">
               <a:s>define &quot;Phone Number&quot;:
  </a:s>
               <a:s r="62">
                  <a:s r="61">
                     <a:s r="58">
                        <a:s>UC</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="61">
                        <a:s>Mobile(</a:s>
                        <a:s r="60">
                           <a:s r="59">
                              <a:s>Patient</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="60">
                              <a:s>telecom</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="62">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="62" locator="51:3-51:34" path="value" xsi:type="Property">
            <source path="value" xsi:type="Property">
               <source localId="61" locator="51:3-51:28" name="Mobile" libraryName="UC" xsi:type="FunctionRef">
                  <operand localId="60" locator="51:13-51:27" path="telecom" xsi:type="Property">
                     <source localId="59" locator="51:13-51:19" name="Patient" xsi:type="ExpressionRef"/>
                  </operand>
               </source>
            </source>
         </expression>
      </def>
      <def localId="70" locator="53:1-55:17" name="Allergies" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="70">
               <a:s>define &quot;Allergies&quot;:
  </a:s>
               <a:s r="69">
                  <a:s>
                     <a:s r="65">
                        <a:s r="64">
                           <a:s>
                              <a:s>UCE.&quot;Active Confirmed Allergies and Intolerances&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> A</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="68">
                     <a:s>return </a:s>
                     <a:s r="67">
                        <a:s r="66">
                           <a:s>A</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="67">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="69" locator="54:3-55:17" xsi:type="Query">
            <source localId="65" locator="54:3-54:53" alias="A">
               <expression localId="64" locator="54:3-54:51" name="Active Confirmed Allergies and Intolerances" libraryName="UCE" xsi:type="ExpressionRef"/>
            </source>
            <return localId="68" locator="55:5-55:17">
               <expression localId="67" locator="55:12-55:17" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="code" scope="A" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="73" locator="60:1-61:39" name="Address" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="73">
               <a:s>// TODO: Error: Could not resolve data provider for package 'java.util'.
// define &quot;Address&quot;:
//   (singleton from Patient.address).line
define &quot;Address&quot;:
  </a:s>
               <a:s r="72">
                  <a:s>{ </a:s>
                  <a:s r="71">
                     <a:s>'TODO: remove hard-coded address'</a:s>
                  </a:s>
                  <a:s> }</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="72" locator="61:3-61:39" xsi:type="List">
            <element localId="71" locator="61:5-61:37" valueType="t:String" value="TODO: remove hard-coded address" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="77" locator="63:1-64:22" name="City" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="77">
               <a:s>define &quot;City&quot;:
  </a:s>
               <a:s r="76">
                  <a:s r="75">
                     <a:s r="74">
                        <a:s>Patient</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="75">
                        <a:s>address</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="76">
                     <a:s>city</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="76" locator="64:3-64:22" xsi:type="Query">
            <source alias="$this">
               <expression localId="75" locator="64:3-64:17" path="address" xsi:type="Property">
                  <source localId="74" locator="64:3-64:9" name="Patient" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand path="value" xsi:type="Property">
                     <source path="city" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </source>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression path="value" xsi:type="Property">
                  <source path="city" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </source>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="81" locator="66:1-67:23" name="State" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="81">
               <a:s>define &quot;State&quot;:
  </a:s>
               <a:s r="80">
                  <a:s r="79">
                     <a:s r="78">
                        <a:s>Patient</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="79">
                        <a:s>address</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="80">
                     <a:s>state</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="80" locator="67:3-67:23" xsi:type="Query">
            <source alias="$this">
               <expression localId="79" locator="67:3-67:17" path="address" xsi:type="Property">
                  <source localId="78" locator="67:3-67:9" name="Patient" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand path="value" xsi:type="Property">
                     <source path="state" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </source>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression path="value" xsi:type="Property">
                  <source path="state" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </source>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="85" locator="69:1-70:28" name="Zip" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="85">
               <a:s>define &quot;Zip&quot;:
  </a:s>
               <a:s r="84">
                  <a:s r="83">
                     <a:s r="82">
                        <a:s>Patient</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="83">
                        <a:s>address</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="84">
                     <a:s>postalCode</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="84" locator="70:3-70:28" xsi:type="Query">
            <source alias="$this">
               <expression localId="83" locator="70:3-70:17" path="address" xsi:type="Property">
                  <source localId="82" locator="70:3-70:9" name="Patient" xsi:type="ExpressionRef"/>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand path="value" xsi:type="Property">
                     <source path="postalCode" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </source>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression path="value" xsi:type="Property">
                  <source path="postalCode" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </source>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="93" locator="72:1-77:15" name="Height" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="93">
               <a:s>define &quot;Height&quot;:
  </a:s>
               <a:s r="92">
                  <a:s>convert</a:s>
                  <a:s r="91">
                     <a:s>(
    </a:s>
                     <a:s r="91">
                        <a:s r="90">
                           <a:s r="86">
                              <a:s>UC</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="90">
                              <a:s>MostRecent(
      </a:s>
                              <a:s r="89">
                                 <a:s r="88">
                                    <a:s r="87">
                                       <a:s>UCE</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="88">
                                       <a:s>&quot;All Body Height Measurements&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="89">
                                    <a:s>resulted()</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    )</a:s>
                           </a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="91">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                     <a:s> 
  )</a:s>
                  </a:s>
                  <a:s> to '[in_i]'</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="92" locator="73:3-77:15" xsi:type="ConvertQuantity">
            <operand localId="91" locator="73:10-77:3" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="value" xsi:type="Property">
                  <source localId="90" locator="74:5-76:5" name="MostRecent" libraryName="UC" xsi:type="FunctionRef">
                     <operand localId="89" locator="75:7-75:51" name="resulted" libraryName="UC" xsi:type="FunctionRef">
                        <operand localId="88" locator="75:7-75:40" name="All Body Height Measurements" libraryName="UCE" xsi:type="ExpressionRef"/>
                     </operand>
                  </source>
               </operand>
            </operand>
            <operand locator="77:8-77:15" valueType="t:String" value="[in_i]" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="96" locator="79:1-80:16" name="Height in [in_i]" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="96">
               <a:s>define &quot;Height in [in_i]&quot;:
  </a:s>
               <a:s r="95">
                  <a:s r="94">
                     <a:s>&quot;Height&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="95">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="95" locator="80:3-80:16" path="value" xsi:type="Property">
            <source localId="94" locator="80:3-80:10" name="Height" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="104" locator="82:1-87:16" name="Weight" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="104">
               <a:s>define &quot;Weight&quot;:
  </a:s>
               <a:s r="103">
                  <a:s>convert</a:s>
                  <a:s r="102">
                     <a:s>(
    </a:s>
                     <a:s r="102">
                        <a:s r="101">
                           <a:s r="97">
                              <a:s>UC</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="101">
                              <a:s>MostRecent(
      </a:s>
                              <a:s r="100">
                                 <a:s r="99">
                                    <a:s r="98">
                                       <a:s>UCE</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="99">
                                       <a:s>&quot;All Body Weight Measurements&quot;</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="100">
                                    <a:s>resulted()</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
    )</a:s>
                           </a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="102">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                     <a:s> 
  )</a:s>
                  </a:s>
                  <a:s> to '[lb_av]'</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="103" locator="83:3-87:16" xsi:type="ConvertQuantity">
            <operand localId="102" locator="83:10-87:3" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="value" xsi:type="Property">
                  <source localId="101" locator="84:5-86:5" name="MostRecent" libraryName="UC" xsi:type="FunctionRef">
                     <operand localId="100" locator="85:7-85:51" name="resulted" libraryName="UC" xsi:type="FunctionRef">
                        <operand localId="99" locator="85:7-85:40" name="All Body Weight Measurements" libraryName="UCE" xsi:type="ExpressionRef"/>
                     </operand>
                  </source>
               </operand>
            </operand>
            <operand locator="87:8-87:16" valueType="t:String" value="[lb_av]" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="107" locator="89:1-90:16" name="Weight in [lb_av]" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="107">
               <a:s>define &quot;Weight in [lb_av]&quot;:
  </a:s>
               <a:s r="106">
                  <a:s r="105">
                     <a:s>&quot;Weight&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="106">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="106" locator="90:3-90:16" path="value" xsi:type="Property">
            <source localId="105" locator="90:3-90:10" name="Weight" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="135" locator="92:1-101:11" name="Most Recent BSA" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="135">
               <a:s>define &quot;Most Recent BSA&quot;:
  </a:s>
               <a:s r="134">
                  <a:s>convert</a:s>
                  <a:s r="133">
                     <a:s>( 
    </a:s>
                     <a:s r="133">
                        <a:s r="132">
                           <a:s r="108">
                              <a:s>UC</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="132">
                              <a:s>MostRecent(
      </a:s>
                              <a:s r="131">
                                 <a:s>(</a:s>
                                 <a:s r="131">
                                    <a:s>
                                       <a:s r="110">
                                          <a:s r="109">
                                             <a:s r="109">
                                                <a:s>[FHIR.Observation: </a:s>
                                                <a:s>
                                                   <a:s>&quot;Body surface area&quot;</a:s>
                                                </a:s>
                                                <a:s>]</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> observation</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>
        </a:s>
                                    <a:s r="130">
                                       <a:s>where </a:s>
                                       <a:s r="130">
                                          <a:s r="123">
                                             <a:s r="116">
                                                <a:s r="112">
                                                   <a:s r="111">
                                                      <a:s>observation</a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="112">
                                                      <a:s>status</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s> ~ </a:s>
                                                <a:s r="115">
                                                   <a:s r="114">
                                                      <a:s r="113">
                                                         <a:s>UC</a:s>
                                                      </a:s>
                                                      <a:s>.</a:s>
                                                      <a:s r="114">
                                                         <a:s>&quot;observation-final&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="115">
                                                      <a:s>code</a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>
          or </a:s>
                                             <a:s r="122">
                                                <a:s r="118">
                                                   <a:s r="117">
                                                      <a:s>observation</a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="118">
                                                      <a:s>status</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s> ~ </a:s>
                                                <a:s r="121">
                                                   <a:s r="120">
                                                      <a:s r="119">
                                                         <a:s>UC</a:s>
                                                      </a:s>
                                                      <a:s>.</a:s>
                                                      <a:s r="120">
                                                         <a:s>&quot;observation-amended&quot;</a:s>
                                                      </a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="121">
                                                      <a:s>code</a:s>
                                                   </a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>
          or </a:s>
                                          <a:s r="129">
                                             <a:s r="125">
                                                <a:s r="124">
                                                   <a:s>observation</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="125">
                                                   <a:s>status</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s> ~ </a:s>
                                             <a:s r="128">
                                                <a:s r="127">
                                                   <a:s r="126">
                                                      <a:s>UC</a:s>
                                                   </a:s>
                                                   <a:s>.</a:s>
                                                   <a:s r="127">
                                                      <a:s>&quot;observation-corrected&quot;</a:s>
                                                   </a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="128">
                                                   <a:s>code</a:s>
                                                </a:s>
                                             </a:s>
                                          </a:s>
                                       </a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
      )</a:s>
                              </a:s>
                              <a:s>
    )</a:s>
                           </a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="133">
                           <a:s>value</a:s>
                        </a:s>
                     </a:s>
                     <a:s> 
  )</a:s>
                  </a:s>
                  <a:s> to 'm2'</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="134" locator="93:3-101:11" xsi:type="ConvertQuantity">
            <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand asType="fhir:Quantity" xsi:type="As">
                  <operand localId="133" locator="93:10-101:3" path="value" xsi:type="Property">
                     <source localId="132" locator="94:5-100:5" name="MostRecent" libraryName="UC" xsi:type="FunctionRef">
                        <operand localId="131" locator="95:7-99:7" xsi:type="Query">
                           <source localId="110" locator="95:8-95:58" alias="observation">
                              <expression localId="109" locator="95:8-95:46" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/Observation" codeProperty="code" codeComparator="~" xsi:type="Retrieve">
                                 <codes xsi:type="ToList">
                                    <operand locator="95:27-95:45" name="Body surface area" xsi:type="CodeRef"/>
                                 </codes>
                              </expression>
                           </source>
                           <where localId="130" locator="96:9-98:65" xsi:type="Or">
                              <operand localId="123" locator="96:15-97:63" xsi:type="Or">
                                 <operand localId="116" locator="96:15-96:62" xsi:type="Equivalent">
                                    <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="112" locator="96:15-96:32" path="status" scope="observation" xsi:type="Property"/>
                                    </operand>
                                    <operand localId="115" locator="96:36-96:62" path="code" xsi:type="Property">
                                       <source localId="114" locator="96:36-96:57" name="observation-final" libraryName="UC" xsi:type="CodeRef"/>
                                    </operand>
                                 </operand>
                                 <operand localId="122" locator="97:14-97:63" xsi:type="Equivalent">
                                    <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand localId="118" locator="97:14-97:31" path="status" scope="observation" xsi:type="Property"/>
                                    </operand>
                                    <operand localId="121" locator="97:35-97:63" path="code" xsi:type="Property">
                                       <source localId="120" locator="97:35-97:58" name="observation-amended" libraryName="UC" xsi:type="CodeRef"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="129" locator="98:14-98:65" xsi:type="Equivalent">
                                 <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="125" locator="98:14-98:31" path="status" scope="observation" xsi:type="Property"/>
                                 </operand>
                                 <operand localId="128" locator="98:35-98:65" path="code" xsi:type="Property">
                                    <source localId="127" locator="98:35-98:60" name="observation-corrected" libraryName="UC" xsi:type="CodeRef"/>
                                 </operand>
                              </operand>
                           </where>
                        </operand>
                     </source>
                  </operand>
               </operand>
            </operand>
            <operand locator="101:8-101:11" valueType="t:String" value="m2" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="177" locator="123:1-137:3" name="CalculateBSA" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="177">
               <a:s>define function CalculateBSA(alg </a:s>
               <a:s r="140">
                  <a:s>System.String</a:s>
               </a:s>
               <a:s>, height </a:s>
               <a:s r="141">
                  <a:s>System.Quantity</a:s>
               </a:s>
               <a:s>, weight </a:s>
               <a:s r="142">
                  <a:s>System.Quantity</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="176">
                  <a:s r="176">
                     <a:s>System.Quantity { </a:s>
                     <a:s>
                        <a:s>value: 
    // Mosteller formula using lbs and inches
    </a:s>
                        <a:s r="174">
                           <a:s>if </a:s>
                           <a:s r="145">
                              <a:s>(</a:s>
                              <a:s r="145">
                                 <a:s r="143">
                                    <a:s>alg</a:s>
                                 </a:s>
                                 <a:s> = </a:s>
                                 <a:s r="144">
                                    <a:s>'Mosteller'</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s> then
      </a:s>
                           <a:s r="155">
                              <a:s r="153">
                                 <a:s>(</a:s>
                                 <a:s r="153">
                                    <a:s r="152">
                                       <a:s>(</a:s>
                                       <a:s r="152">
                                          <a:s r="150">
                                             <a:s>(</a:s>
                                             <a:s r="150">
                                                <a:s r="147">
                                                   <a:s>(</a:s>
                                                   <a:s r="147">
                                                      <a:s>convert</a:s>
                                                      <a:s r="146">
                                                         <a:s>(</a:s>
                                                         <a:s r="146">
                                                            <a:s>height</a:s>
                                                         </a:s>
                                                         <a:s>)</a:s>
                                                      </a:s>
                                                      <a:s> to '[in_i]'</a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                                <a:s> * </a:s>
                                                <a:s r="149">
                                                   <a:s>(</a:s>
                                                   <a:s r="149">
                                                      <a:s>convert</a:s>
                                                      <a:s r="148">
                                                         <a:s>(</a:s>
                                                         <a:s r="148">
                                                            <a:s>weight</a:s>
                                                         </a:s>
                                                         <a:s>)</a:s>
                                                      </a:s>
                                                      <a:s> to '[lb_av]'</a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                          <a:s r="151">/3131</a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="153">
                                       <a:s>value</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s r="154">^0.5</a:s>
                           </a:s>
                           <a:s>
    
    // DuBois and DuBois formula using cm and kg
    // NOTE: never to be used for newborn calculation
    else </a:s>
                           <a:s r="173">
                              <a:s>if </a:s>
                              <a:s r="158">
                                 <a:s>(</a:s>
                                 <a:s r="158">
                                    <a:s r="156">
                                       <a:s>alg</a:s>
                                    </a:s>
                                    <a:s> = </a:s>
                                    <a:s r="157">
                                       <a:s>'DuBois and DuBois'</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s> then
      </a:s>
                              <a:s r="171">
                                 <a:s r="165">
                                    <a:s r="159">0.007184 * </a:s>
                                    <a:s r="164">
                                       <a:s>(</a:s>
                                       <a:s r="164">
                                          <a:s r="162">
                                             <a:s r="161">
                                                <a:s>(</a:s>
                                                <a:s r="161">
                                                   <a:s>convert</a:s>
                                                   <a:s r="160">
                                                      <a:s>(</a:s>
                                                      <a:s r="160">
                                                         <a:s>height</a:s>
                                                      </a:s>
                                                      <a:s>)</a:s>
                                                   </a:s>
                                                   <a:s> to 'cm'</a:s>
                                                </a:s>
                                                <a:s>)</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="162">
                                                <a:s>value</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s r="163">^0.725</a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> * </a:s>
                                 <a:s r="170">
                                    <a:s>(</a:s>
                                    <a:s r="170">
                                       <a:s r="168">
                                          <a:s r="167">
                                             <a:s>(</a:s>
                                             <a:s r="167">
                                                <a:s>convert</a:s>
                                                <a:s r="166">
                                                   <a:s>(</a:s>
                                                   <a:s r="166">
                                                      <a:s>weight</a:s>
                                                   </a:s>
                                                   <a:s>)</a:s>
                                                </a:s>
                                                <a:s> to 'kg'</a:s>
                                             </a:s>
                                             <a:s>)</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="168">
                                             <a:s>value</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s r="169">^0.425</a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s r="172">
    
    // No matching algorithm found
    else null</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>,
    </a:s>
                     <a:s>
                        <a:s>unit: </a:s>
                        <a:s r="175">
                           <a:s>'m2'</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  }</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="176" locator="124:3-137:3" classType="t:Quantity" xsi:type="Instance">
            <element name="value">
               <value localId="174" locator="126:5-135:13" xsi:type="If">
                  <condition localId="145" locator="126:8-126:26" xsi:type="Equal">
                     <operand localId="143" locator="126:9-126:11" name="alg" xsi:type="OperandRef"/>
                     <operand localId="144" locator="126:15-126:25" valueType="t:String" value="Mosteller" xsi:type="Literal"/>
                  </condition>
                  <then localId="155" locator="127:7-127:89" xsi:type="Power">
                     <operand localId="153" locator="127:7-127:85" path="value" xsi:type="Property">
                        <source localId="152" locator="127:8-127:78" xsi:type="Divide">
                           <operand localId="150" locator="127:9-127:72" xsi:type="Multiply">
                              <operand localId="147" locator="127:10-127:38" xsi:type="ConvertQuantity">
                                 <operand localId="146" locator="127:18-127:25" name="height" xsi:type="OperandRef"/>
                                 <operand locator="127:30-127:37" valueType="t:String" value="[in_i]" xsi:type="Literal"/>
                              </operand>
                              <operand localId="149" locator="127:42-127:71" xsi:type="ConvertQuantity">
                                 <operand localId="148" locator="127:50-127:57" name="weight" xsi:type="OperandRef"/>
                                 <operand locator="127:62-127:70" valueType="t:String" value="[lb_av]" xsi:type="Literal"/>
                              </operand>
                           </operand>
                           <operand xsi:type="ToQuantity">
                              <operand localId="151" locator="127:74-127:77" valueType="t:Integer" value="3131" xsi:type="Literal"/>
                           </operand>
                        </source>
                     </operand>
                     <operand localId="154" locator="127:87-127:89" valueType="t:Decimal" value="0.5" xsi:type="Literal"/>
                  </then>
                  <else localId="173" locator="131:10-135:13" xsi:type="If">
                     <condition localId="158" locator="131:13-131:39" xsi:type="Equal">
                        <operand localId="156" locator="131:14-131:16" name="alg" xsi:type="OperandRef"/>
                        <operand localId="157" locator="131:20-131:38" valueType="t:String" value="DuBois and DuBois" xsi:type="Literal"/>
                     </condition>
                     <then localId="171" locator="132:7-132:98" xsi:type="Multiply">
                        <operand localId="165" locator="132:7-132:56" xsi:type="Multiply">
                           <operand localId="159" locator="132:7-132:14" valueType="t:Decimal" value="0.007184" xsi:type="Literal"/>
                           <operand localId="164" locator="132:18-132:56" xsi:type="Power">
                              <operand localId="162" locator="132:19-132:49" path="value" xsi:type="Property">
                                 <source localId="161" locator="132:19-132:43" xsi:type="ConvertQuantity">
                                    <operand localId="160" locator="132:27-132:34" name="height" xsi:type="OperandRef"/>
                                    <operand locator="132:39-132:42" valueType="t:String" value="cm" xsi:type="Literal"/>
                                 </source>
                              </operand>
                              <operand localId="163" locator="132:51-132:55" valueType="t:Decimal" value="0.725" xsi:type="Literal"/>
                           </operand>
                        </operand>
                        <operand localId="170" locator="132:60-132:98" xsi:type="Power">
                           <operand localId="168" locator="132:61-132:91" path="value" xsi:type="Property">
                              <source localId="167" locator="132:61-132:85" xsi:type="ConvertQuantity">
                                 <operand localId="166" locator="132:69-132:76" name="weight" xsi:type="OperandRef"/>
                                 <operand locator="132:81-132:84" valueType="t:String" value="kg" xsi:type="Literal"/>
                              </source>
                           </operand>
                           <operand localId="169" locator="132:93-132:97" valueType="t:Decimal" value="0.425" xsi:type="Literal"/>
                        </operand>
                     </then>
                     <else asType="t:Decimal" xsi:type="As">
                        <operand localId="172" locator="135:10-135:13" xsi:type="Null"/>
                     </else>
                  </else>
               </value>
            </element>
            <element name="unit">
               <value localId="175" locator="136:11-136:14" valueType="t:String" value="m2" xsi:type="Literal"/>
            </element>
         </expression>
         <operand name="alg">
            <operandTypeSpecifier localId="140" locator="123:34-123:46" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="height">
            <operandTypeSpecifier localId="141" locator="123:56-123:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="weight">
            <operandTypeSpecifier localId="142" locator="123:80-123:94" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="179" locator="110:1-111:47" name="Calculated BSA - Mosteller" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="179">
               <a:s>// Mosteller formula using lbs and inches
define &quot;Calculated BSA - Mosteller&quot;:
  </a:s>
               <a:s r="178">
                  <a:s>CalculateBSA(</a:s>
                  <a:s r="137">
                     <a:s>'Mosteller'</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="138">
                     <a:s>&quot;Height&quot;</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="139">
                     <a:s>&quot;Weight&quot;</a:s>
                  </a:s>
                  <a:s>)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="178" locator="111:3-111:47" name="CalculateBSA" xsi:type="FunctionRef">
            <operand localId="137" locator="111:16-111:26" valueType="t:String" value="Mosteller" xsi:type="Literal"/>
            <operand localId="138" locator="111:29-111:36" name="Height" xsi:type="ExpressionRef"/>
            <operand localId="139" locator="111:39-111:46" name="Weight" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="182" locator="103:1-104:59" name="BSA" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="182">
               <a:s>define &quot;BSA&quot;:
  </a:s>
               <a:s r="181">
                  <a:s>Coalesce(</a:s>
                  <a:s r="136">
                     <a:s>&quot;Most Recent BSA&quot;</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="180">
                     <a:s>&quot;Calculated BSA - Mosteller&quot;</a:s>
                  </a:s>
                  <a:s>)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="181" locator="104:3-104:59" xsi:type="Coalesce">
            <operand localId="136" locator="104:12-104:28" name="Most Recent BSA" xsi:type="ExpressionRef"/>
            <operand localId="180" locator="104:31-104:58" name="Calculated BSA - Mosteller" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="185" locator="106:1-107:13" name="BSA in m2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="185">
               <a:s>define &quot;BSA in m2&quot;:
  </a:s>
               <a:s r="184">
                  <a:s r="183">
                     <a:s>&quot;BSA&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="184">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="184" locator="107:3-107:13" path="value" xsi:type="Property">
            <source localId="183" locator="107:3-107:7" name="BSA" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="188" locator="114:1-115:27" name="Height in cm" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="188">
               <a:s>//(((&quot;Weight&quot;*&quot;Height&quot;)/3131).value)^0.5
define &quot;Height in cm&quot;:
  </a:s>
               <a:s r="187">
                  <a:s>convert</a:s>
                  <a:s r="186">
                     <a:s>(</a:s>
                     <a:s r="186">
                        <a:s>&quot;Height&quot;</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s> to 'cm'</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="187" locator="115:3-115:27" xsi:type="ConvertQuantity">
            <operand localId="186" locator="115:10-115:19" name="Height" xsi:type="ExpressionRef"/>
            <operand locator="115:24-115:27" valueType="t:String" value="cm" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="191" locator="117:1-118:27" name="Weight in kg" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="191">
               <a:s>define &quot;Weight in kg&quot;:
  </a:s>
               <a:s r="190">
                  <a:s>convert</a:s>
                  <a:s r="189">
                     <a:s>(</a:s>
                     <a:s r="189">
                        <a:s>&quot;Weight&quot;</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s> to 'kg'</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="190" locator="118:3-118:27" xsi:type="ConvertQuantity">
            <operand localId="189" locator="118:10-118:19" name="Weight" xsi:type="ExpressionRef"/>
            <operand locator="118:24-118:27" valueType="t:String" value="kg" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="196" locator="120:1-121:55" name="Calculated BSA - DuBois and DuBois" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="196">
               <a:s>define &quot;Calculated BSA - DuBois and DuBois&quot;:
  </a:s>
               <a:s r="195">
                  <a:s>CalculateBSA(</a:s>
                  <a:s r="192">
                     <a:s>'DuBois and DuBois'</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="193">
                     <a:s>&quot;Height&quot;</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="194">
                     <a:s>&quot;Weight&quot;</a:s>
                  </a:s>
                  <a:s>)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="195" locator="121:3-121:55" name="CalculateBSA" xsi:type="FunctionRef">
            <operand localId="192" locator="121:16-121:34" valueType="t:String" value="DuBois and DuBois" xsi:type="Literal"/>
            <operand localId="193" locator="121:37-121:44" name="Height" xsi:type="ExpressionRef"/>
            <operand localId="194" locator="121:47-121:54" name="Weight" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="203" locator="140:1-141:17" name="Birth Sex" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="203">
               <a:s>// QUESTION: do we want to use Patient.gender as a backup? If so we'll need a ConceptMap or translation
define &quot;Birth Sex&quot;:
 </a:s>
               <a:s r="202">
                  <a:s r="201">
                     <a:s>Patient</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="202">
                     <a:s>birthsex</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="202" locator="141:2-141:17" xsi:type="SingletonFrom">
            <operand xsi:type="Query">
               <source alias="$this">
                  <expression path="extension" xsi:type="Property">
                     <source localId="201" locator="141:2-141:8" name="Patient" xsi:type="ExpressionRef"/>
                  </expression>
               </source>
               <where xsi:type="Equal">
                  <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="url" scope="$this" xsi:type="Property"/>
                  </operand>
                  <operand valueType="t:String" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex" xsi:type="Literal"/>
               </where>
               <return distinct="false">
                  <expression path="value.value" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </expression>
               </return>
            </operand>
         </expression>
      </def>
      <def localId="210" locator="143:1-145:17" name="Diagnosis Codes" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="210">
               <a:s>define &quot;Diagnosis Codes&quot;:
  </a:s>
               <a:s r="209">
                  <a:s>
                     <a:s r="205">
                        <a:s r="204">
                           <a:s>
                              <a:s>UCE.&quot;All Conditions&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="208">
                     <a:s>return </a:s>
                     <a:s r="207">
                        <a:s r="206">
                           <a:s>C</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="207">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="209" locator="144:3-145:17" xsi:type="Query">
            <source localId="205" locator="144:3-144:24" alias="C">
               <expression localId="204" locator="144:3-144:22" name="All Conditions" libraryName="UCE" xsi:type="ExpressionRef"/>
            </source>
            <return localId="208" locator="145:5-145:17">
               <expression localId="207" locator="145:12-145:17" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="code" scope="C" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="224" locator="147:1-149:65" name="Diagnosis Descriptions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="224">
               <a:s>define &quot;Diagnosis Descriptions&quot;:
  </a:s>
               <a:s r="223">
                  <a:s>
                     <a:s r="212">
                        <a:s r="211">
                           <a:s>
                              <a:s>&quot;Diagnosis Codes&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> ConceptItem</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="222">
                     <a:s>return </a:s>
                     <a:s r="221">
                        <a:s>Combine(</a:s>
                        <a:s r="219">
                           <a:s>(</a:s>
                           <a:s r="219">
                              <a:s>
                                 <a:s r="215">
                                    <a:s r="214">
                                       <a:s>(</a:s>
                                       <a:s r="214">
                                          <a:s r="213">
                                             <a:s>ConceptItem</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="214">
                                             <a:s>codes</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                    <a:s> C</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> </a:s>
                              <a:s r="218">
                                 <a:s>return </a:s>
                                 <a:s r="217">
                                    <a:s r="216">
                                       <a:s>C</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="217">
                                       <a:s>display</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="220">
                           <a:s>'|'</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="223" locator="148:3-149:65" xsi:type="Query">
            <source localId="212" locator="148:3-148:31" alias="ConceptItem">
               <expression localId="211" locator="148:3-148:19" name="Diagnosis Codes" xsi:type="ExpressionRef"/>
            </source>
            <return localId="222" locator="149:5-149:65">
               <expression localId="221" locator="149:12-149:65" xsi:type="Combine">
                  <source localId="219" locator="149:20-149:59" xsi:type="Query">
                     <source localId="215" locator="149:21-149:41" alias="C">
                        <expression localId="214" locator="149:21-149:39" path="codes" scope="ConceptItem" xsi:type="Property"/>
                     </source>
                     <return localId="218" locator="149:43-149:58">
                        <expression localId="217" locator="149:50-149:58" path="display" scope="C" xsi:type="Property"/>
                     </return>
                  </source>
                  <separator localId="220" locator="149:62-149:64" valueType="t:String" value="|" xsi:type="Literal"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="229" locator="163:1-164:38" name="Most Recent Medication Request" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="229">
               <a:s>define &quot;Most Recent Medication Request&quot;:
  </a:s>
               <a:s r="228">
                  <a:s r="227">
                     <a:s>UCE</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="228">
                     <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="228" locator="164:3-164:38" name="Most Recent Medication Request" libraryName="UCE" xsi:type="ExpressionRef"/>
      </def>
      <def localId="239" locator="151:1-153:101" name="Medication Requested" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="239">
               <a:s>define &quot;Medication Requested&quot;:
  </a:s>
               <a:s r="238">
                  <a:s>
                     <a:s r="226">
                        <a:s r="225">
                           <a:s>
                              <a:s>UCE.&quot;All Medications&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> M</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="237">
                     <a:s>where </a:s>
                     <a:s r="237">
                        <a:s>EndsWith(</a:s>
                        <a:s r="234">
                           <a:s r="233">
                              <a:s>(</a:s>
                              <a:s r="233">
                                 <a:s r="231">
                                    <a:s r="230">
                                       <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="231">
                                       <a:s>medication</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> as </a:s>
                                 <a:s r="232">
                                    <a:s>USCore.Reference</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="234">
                              <a:s>reference</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="236">
                           <a:s r="235">
                              <a:s>M</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="236">
                              <a:s>id</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="238" locator="152:3-153:101" xsi:type="Query">
            <source localId="226" locator="152:3-152:25" alias="M">
               <expression localId="225" locator="152:3-152:23" name="All Medications" libraryName="UCE" xsi:type="ExpressionRef"/>
            </source>
            <where localId="237" locator="153:5-153:101" xsi:type="EndsWith">
               <operand localId="234" locator="153:20-153:94" path="value" xsi:type="Property">
                  <source path="reference" xsi:type="Property">
                     <source localId="233" locator="153:20-153:84" strict="false" xsi:type="As">
                        <operand localId="231" locator="153:21-153:63" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand path="medication" xsi:type="Property">
                              <source localId="230" locator="153:21-153:52" name="Most Recent Medication Request" xsi:type="ExpressionRef"/>
                           </operand>
                        </operand>
                        <asTypeSpecifier localId="232" locator="153:68-153:83" name="fhir:Reference" xsi:type="NamedTypeSpecifier"/>
                     </source>
                  </source>
               </operand>
               <operand localId="236" locator="153:97-153:100" path="value" xsi:type="Property">
                  <source path="id" scope="M" xsi:type="Property"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="247" locator="155:1-157:25" name="Medication Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="247">
               <a:s>define &quot;Medication Name&quot;:
  </a:s>
               <a:s r="246">
                  <a:s>
                     <a:s r="241">
                        <a:s r="240">
                           <a:s>
                              <a:s>&quot;Medication Requested&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> M</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="245">
                     <a:s>return </a:s>
                     <a:s r="244">
                        <a:s r="243">
                           <a:s r="242">
                              <a:s>M</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="243">
                              <a:s>code</a:s>
                           </a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="244">
                           <a:s>display</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="246" locator="156:3-157:25" xsi:type="Query">
            <source localId="241" locator="156:3-156:26" alias="M">
               <expression localId="240" locator="156:3-156:24" name="Medication Requested" xsi:type="ExpressionRef"/>
            </source>
            <return localId="245" locator="157:5-157:25">
               <expression localId="244" locator="157:12-157:25" path="display" xsi:type="Property">
                  <source localId="243" locator="157:12-157:17" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="code" scope="M" xsi:type="Property"/>
                  </source>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="254" locator="159:1-161:17" name="Code of Requested Drug" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="254">
               <a:s>define &quot;Code of Requested Drug&quot;:
  </a:s>
               <a:s r="253">
                  <a:s>
                     <a:s r="249">
                        <a:s r="248">
                           <a:s>
                              <a:s>&quot;Medication Requested&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> M</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="252">
                     <a:s>return </a:s>
                     <a:s r="251">
                        <a:s r="250">
                           <a:s>M</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="251">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="253" locator="160:3-161:17" xsi:type="Query">
            <source localId="249" locator="160:3-160:26" alias="M">
               <expression localId="248" locator="160:3-160:24" name="Medication Requested" xsi:type="ExpressionRef"/>
            </source>
            <return localId="252" locator="161:5-161:17">
               <expression localId="251" locator="161:12-161:17" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="code" scope="M" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="260" locator="166:1-167:77" name="Medication Request References" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="260">
               <a:s>define &quot;Medication Request References&quot;:
  </a:s>
               <a:s r="259">
                  <a:s r="258">
                     <a:s>(</a:s>
                     <a:s r="258">
                        <a:s r="256">
                           <a:s r="255">
                              <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="256">
                              <a:s>medication</a:s>
                           </a:s>
                        </a:s>
                        <a:s> as </a:s>
                        <a:s r="257">
                           <a:s>USCore.Reference</a:s>
                        </a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="259">
                     <a:s>reference</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="259" locator="167:3-167:77" path="value" xsi:type="Property">
            <source path="reference" xsi:type="Property">
               <source localId="258" locator="167:3-167:67" strict="false" xsi:type="As">
                  <operand localId="256" locator="167:4-167:46" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="medication" xsi:type="Property">
                        <source localId="255" locator="167:4-167:35" name="Most Recent Medication Request" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
                  <asTypeSpecifier localId="257" locator="167:51-167:66" name="fhir:Reference" xsi:type="NamedTypeSpecifier"/>
               </source>
            </source>
         </expression>
      </def>
      <def localId="264" locator="169:1-171:67" name="Most Recent Medication Request dosageInstruction" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="264">
               <a:s>define &quot;Most Recent Medication Request dosageInstruction&quot;:
  // TODO: should this really be a singleton?
  </a:s>
               <a:s r="263">
                  <a:s>singleton from </a:s>
                  <a:s r="262">
                     <a:s r="261">
                        <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="262">
                        <a:s>dosageInstruction</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="263" locator="171:3-171:67" xsi:type="SingletonFrom">
            <operand localId="262" locator="171:18-171:67" path="dosageInstruction" xsi:type="Property">
               <source localId="261" locator="171:18-171:49" name="Most Recent Medication Request" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="268" locator="173:1-175:79" name="Most Recent Medication Request dosageInstruction.doseAndRate" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="268">
               <a:s>define &quot;Most Recent Medication Request dosageInstruction.doseAndRate&quot;:
  // TODO: should this really be a singleton?
  </a:s>
               <a:s r="267">
                  <a:s>singleton from </a:s>
                  <a:s r="266">
                     <a:s r="265">
                        <a:s>&quot;Most Recent Medication Request dosageInstruction&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="266">
                        <a:s>doseAndRate</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="267" locator="175:3-175:79" xsi:type="SingletonFrom">
            <operand localId="266" locator="175:18-175:79" path="doseAndRate" xsi:type="Property">
               <source localId="265" locator="175:18-175:67" name="Most Recent Medication Request dosageInstruction" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="271" locator="177:1-178:69" name="Medication Dose" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="271">
               <a:s>define &quot;Medication Dose&quot;:
  </a:s>
               <a:s r="270">
                  <a:s r="269">
                     <a:s>&quot;Most Recent Medication Request dosageInstruction.doseAndRate&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="270">
                     <a:s>dose</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="270" locator="178:3-178:69" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
            <operand path="dose" xsi:type="Property">
               <source localId="269" locator="178:3-178:64" name="Most Recent Medication Request dosageInstruction.doseAndRate" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="274" locator="180:1-181:58" name="Medication Route" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="274">
               <a:s>define &quot;Medication Route&quot;:
  </a:s>
               <a:s r="273">
                  <a:s r="272">
                     <a:s>&quot;Most Recent Medication Request dosageInstruction&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="273">
                     <a:s>route</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="273" locator="181:3-181:58" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
            <operand path="route" xsi:type="Property">
               <source localId="272" locator="181:3-181:52" name="Most Recent Medication Request dosageInstruction" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="279" locator="183:1-184:76" name="Medication Frequency value" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="279">
               <a:s>define &quot;Medication Frequency value&quot;:
  </a:s>
               <a:s r="278">
                  <a:s r="277">
                     <a:s r="276">
                        <a:s r="275">
                           <a:s>&quot;Most Recent Medication Request dosageInstruction&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="276">
                           <a:s>timing</a:s>
                        </a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="277">
                        <a:s>repeat</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="278">
                     <a:s>frequency</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="278" locator="184:3-184:76" path="value" xsi:type="Property">
            <source path="frequency" xsi:type="Property">
               <source localId="277" locator="184:3-184:66" path="repeat" xsi:type="Property">
                  <source localId="276" locator="184:3-184:59" path="timing" xsi:type="Property">
                     <source localId="275" locator="184:3-184:52" name="Most Recent Medication Request dosageInstruction" xsi:type="ExpressionRef"/>
                  </source>
               </source>
            </source>
         </expression>
      </def>
      <def localId="296" locator="186:1-193:5" name="Medication Frequency Period" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="296">
               <a:s>define &quot;Medication Frequency Period&quot;:
  </a:s>
               <a:s r="295">
                  <a:s>if </a:s>
                  <a:s r="284">
                     <a:s>(</a:s>
                     <a:s r="284">
                        <a:s>IsNull(</a:s>
                        <a:s r="283">
                           <a:s r="282">
                              <a:s r="281">
                                 <a:s r="280">
                                    <a:s>&quot;Most Recent Medication Request dosageInstruction&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="281">
                                    <a:s>timing</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="282">
                                 <a:s>repeat</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="283">
                              <a:s>period</a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s r="285"> then 
    null
  else
    </a:s>
                  <a:s r="294">
                     <a:s>System.Quantity {
      </a:s>
                     <a:s>
                        <a:s>value: </a:s>
                        <a:s r="289">
                           <a:s r="288">
                              <a:s r="287">
                                 <a:s r="286">
                                    <a:s>&quot;Most Recent Medication Request dosageInstruction&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="287">
                                    <a:s>timing</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="288">
                                 <a:s>repeat</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="289">
                              <a:s>period</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>,
      </a:s>
                     <a:s>
                        <a:s>unit: </a:s>
                        <a:s r="293">
                           <a:s r="292">
                              <a:s r="291">
                                 <a:s r="290">
                                    <a:s>&quot;Most Recent Medication Request dosageInstruction&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="291">
                                    <a:s>timing</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="292">
                                 <a:s>repeat</a:s>
                              </a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="293">
                              <a:s>periodUnit</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    }</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="295" locator="187:3-193:5" xsi:type="If">
            <condition localId="284" locator="187:6-187:86" xsi:type="IsNull">
               <operand localId="283" locator="187:14-187:84" path="value" xsi:type="Property">
                  <source path="period" xsi:type="Property">
                     <source localId="282" locator="187:14-187:77" path="repeat" xsi:type="Property">
                        <source localId="281" locator="187:14-187:70" path="timing" xsi:type="Property">
                           <source localId="280" locator="187:14-187:63" name="Most Recent Medication Request dosageInstruction" xsi:type="ExpressionRef"/>
                        </source>
                     </source>
                  </source>
               </operand>
            </condition>
            <then asType="t:Quantity" xsi:type="As">
               <operand localId="285" locator="188:5-188:8" xsi:type="Null"/>
            </then>
            <else localId="294" locator="190:5-193:5" classType="t:Quantity" xsi:type="Instance">
               <element name="value">
                  <value localId="289" locator="191:14-191:84" path="value" xsi:type="Property">
                     <source path="period" xsi:type="Property">
                        <source localId="288" locator="191:14-191:77" path="repeat" xsi:type="Property">
                           <source localId="287" locator="191:14-191:70" path="timing" xsi:type="Property">
                              <source localId="286" locator="191:14-191:63" name="Most Recent Medication Request dosageInstruction" xsi:type="ExpressionRef"/>
                           </source>
                        </source>
                     </source>
                  </value>
               </element>
               <element name="unit">
                  <value localId="293" locator="192:13-192:87" path="value" xsi:type="Property">
                     <source path="periodUnit" xsi:type="Property">
                        <source localId="292" locator="192:13-192:76" path="repeat" xsi:type="Property">
                           <source localId="291" locator="192:13-192:69" path="timing" xsi:type="Property">
                              <source localId="290" locator="192:13-192:62" name="Most Recent Medication Request dosageInstruction" xsi:type="ExpressionRef"/>
                           </source>
                        </source>
                     </source>
                  </value>
               </element>
            </else>
         </expression>
      </def>
      <def localId="312" locator="195:1-198:42" name="Medication Frequency" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="312">
               <a:s>define &quot;Medication Frequency&quot;: // '1x per 1d', '3x per 2wk', '1x per 1mo'
  </a:s>
               <a:s r="311">
                  <a:s r="308">
                     <a:s r="306">
                        <a:s r="302">
                           <a:s r="300">
                              <a:s r="298">
                                 <a:s>ToString(</a:s>
                                 <a:s r="297">
                                    <a:s>&quot;Medication Frequency value&quot;</a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="299">
                                 <a:s>'x'</a:s>
                              </a:s>
                           </a:s>
                           <a:s> +
  </a:s>
                           <a:s r="301">
                              <a:s>' per '</a:s>
                           </a:s>
                        </a:s>
                        <a:s> + </a:s>
                        <a:s r="305">
                           <a:s>ToString(</a:s>
                           <a:s r="304">
                              <a:s r="303">
                                 <a:s>&quot;Medication Frequency Period&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="304">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s> + 
  </a:s>
                     <a:s r="307">
                        <a:s>' '</a:s>
                     </a:s>
                  </a:s>
                  <a:s> + </a:s>
                  <a:s r="310">
                     <a:s r="309">
                        <a:s>&quot;Medication Frequency Period&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="310">
                        <a:s>unit</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="311" locator="196:3-198:42" xsi:type="Concatenate">
            <operand localId="308" locator="196:3-198:5" xsi:type="Concatenate">
               <operand localId="306" locator="196:3-197:57" xsi:type="Concatenate">
                  <operand localId="302" locator="196:3-197:9" xsi:type="Concatenate">
                     <operand localId="300" locator="196:3-196:46" xsi:type="Concatenate">
                        <operand localId="298" locator="196:3-196:40" xsi:type="ToString">
                           <operand localId="297" locator="196:12-196:39" name="Medication Frequency value" xsi:type="ExpressionRef"/>
                        </operand>
                        <operand localId="299" locator="196:44-196:46" valueType="t:String" value="x" xsi:type="Literal"/>
                     </operand>
                     <operand localId="301" locator="197:3-197:9" valueType="t:String" value=" per " xsi:type="Literal"/>
                  </operand>
                  <operand localId="305" locator="197:13-197:57" xsi:type="ToString">
                     <operand localId="304" locator="197:22-197:56" path="value" xsi:type="Property">
                        <source localId="303" locator="197:22-197:50" name="Medication Frequency Period" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="307" locator="198:3-198:5" valueType="t:String" value=" " xsi:type="Literal"/>
            </operand>
            <operand localId="310" locator="198:9-198:42" path="unit" xsi:type="Property">
               <source localId="309" locator="198:9-198:37" name="Medication Frequency Period" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="316" locator="200:1-201:59" name="Quantity or Number of requested Visits" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="316">
               <a:s>define &quot;Quantity or Number of requested Visits&quot;:
  </a:s>
               <a:s r="315">
                  <a:s r="314">
                     <a:s r="313">
                        <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="314">
                        <a:s>dispenseRequest</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="315">
                     <a:s>quantity</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="315" locator="201:3-201:59" name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
            <operand path="quantity" xsi:type="Property">
               <source localId="314" locator="201:3-201:50" path="dispenseRequest" xsi:type="Property">
                  <source localId="313" locator="201:3-201:34" name="Most Recent Medication Request" xsi:type="ExpressionRef"/>
               </source>
            </operand>
         </expression>
      </def>
      <def localId="319" locator="203:1-204:52" name="Prior Prescription" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="319">
               <a:s>define &quot;Prior Prescription&quot;:
  </a:s>
               <a:s r="318">
                  <a:s r="317">
                     <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="318">
                     <a:s>priorPrescription</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="318" locator="204:3-204:52" path="priorPrescription" xsi:type="Property">
            <source localId="317" locator="204:3-204:34" name="Most Recent Medication Request" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="322" locator="206:1-207:30" name="New therapy" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="322">
               <a:s>define &quot;New therapy&quot;:
  </a:s>
               <a:s r="321">
                  <a:s>IsNull(</a:s>
                  <a:s r="320">
                     <a:s>&quot;Prior Prescription&quot;</a:s>
                  </a:s>
                  <a:s>)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="321" locator="207:3-207:30" xsi:type="IsNull">
            <operand localId="320" locator="207:10-207:29" name="Prior Prescription" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="331" locator="209:1-213:80" name="New therapy code" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="331">
               <a:s>define &quot;New therapy code&quot;:
  </a:s>
               <a:s r="330">
                  <a:s>if </a:s>
                  <a:s r="323">
                     <a:s>(</a:s>
                     <a:s r="323">
                        <a:s>&quot;New therapy&quot;</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
                  <a:s> then
    </a:s>
                  <a:s r="326">
                     <a:s>System.Code { </a:s>
                     <a:s>
                        <a:s>code: </a:s>
                        <a:s r="324">
                           <a:s>'NewMedication'</a:s>
                        </a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s>
                        <a:s>display: </a:s>
                        <a:s r="325">
                           <a:s>'New Medication'</a:s>
                        </a:s>
                     </a:s>
                     <a:s> }</a:s>
                  </a:s>
                  <a:s>
  else
    </a:s>
                  <a:s r="329">
                     <a:s>System.Code { </a:s>
                     <a:s>
                        <a:s>code: </a:s>
                        <a:s r="327">
                           <a:s>'ContinuedTherapy'</a:s>
                        </a:s>
                     </a:s>
                     <a:s>, </a:s>
                     <a:s>
                        <a:s>display: </a:s>
                        <a:s r="328">
                           <a:s>'Continuation of therapy'</a:s>
                        </a:s>
                     </a:s>
                     <a:s> }</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="330" locator="210:3-213:80" xsi:type="If">
            <condition localId="323" locator="210:6-210:20" name="New therapy" xsi:type="ExpressionRef"/>
            <then localId="326" locator="211:5-211:68" classType="t:Code" xsi:type="Instance">
               <element name="code">
                  <value localId="324" locator="211:25-211:39" valueType="t:String" value="NewMedication" xsi:type="Literal"/>
               </element>
               <element name="display">
                  <value localId="325" locator="211:51-211:66" valueType="t:String" value="New Medication" xsi:type="Literal"/>
               </element>
            </then>
            <else localId="329" locator="213:5-213:80" classType="t:Code" xsi:type="Instance">
               <element name="code">
                  <value localId="327" locator="213:25-213:42" valueType="t:String" value="ContinuedTherapy" xsi:type="Literal"/>
               </element>
               <element name="display">
                  <value localId="328" locator="213:54-213:78" valueType="t:String" value="Continuation of therapy" xsi:type="Literal"/>
               </element>
            </else>
         </expression>
      </def>
      <def localId="350" locator="217:1-223:8" name="Initial date of therapy" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="350">
               <a:s>// MISSING: needs test data to validate
//Initial date of therapy does not return correct result if there have been more than 1 prior Prescriptions - logic needs to be adapted to that case
define &quot;Initial date of therapy&quot;:
  </a:s>
               <a:s r="349">
                  <a:s>if </a:s>
                  <a:s r="333">
                     <a:s>not </a:s>
                     <a:s r="332">
                        <a:s>&quot;New therapy&quot;</a:s>
                     </a:s>
                  </a:s>
                  <a:s> then
    </a:s>
                  <a:s r="347">
                     <a:s>
                        <a:s r="335">
                           <a:s r="334">
                              <a:s>
                                 <a:s>UCE.&quot;All Medication Requests&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s> M</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
      </a:s>
                     <a:s r="343">
                        <a:s>where </a:s>
                        <a:s r="343">
                           <a:s>EndsWith(</a:s>
                           <a:s r="340">
                              <a:s r="339">
                                 <a:s>(</a:s>
                                 <a:s r="339">
                                    <a:s r="337">
                                       <a:s r="336">
                                          <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="337">
                                          <a:s>priorPrescription</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="338">
                                       <a:s>USCore.Reference</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="340">
                                 <a:s>reference</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="342">
                              <a:s r="341">
                                 <a:s>M</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="342">
                                 <a:s>id</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
      </a:s>
                     <a:s r="346">
                        <a:s>return </a:s>
                        <a:s r="345">
                           <a:s r="344">
                              <a:s>M</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="345">
                              <a:s>authoredOn</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s r="348">
  else 
    null</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="349" locator="218:3-223:8" xsi:type="If">
            <condition localId="333" locator="218:6-218:22" xsi:type="Not">
               <operand localId="332" locator="218:10-218:22" name="New therapy" xsi:type="ExpressionRef"/>
            </condition>
            <then localId="347" locator="219:5-221:25" xsi:type="Query">
               <source localId="335" locator="219:5-219:35" alias="M">
                  <expression localId="334" locator="219:5-219:33" name="All Medication Requests" libraryName="UCE" xsi:type="ExpressionRef"/>
               </source>
               <where localId="343" locator="220:7-220:110" xsi:type="EndsWith">
                  <operand localId="340" locator="220:22-220:103" path="value" xsi:type="Property">
                     <source path="reference" xsi:type="Property">
                        <source localId="339" locator="220:22-220:93" strict="false" xsi:type="As">
                           <operand localId="337" locator="220:23-220:72" path="priorPrescription" xsi:type="Property">
                              <source localId="336" locator="220:23-220:54" name="Most Recent Medication Request" xsi:type="ExpressionRef"/>
                           </operand>
                           <asTypeSpecifier localId="338" locator="220:77-220:92" name="fhir:Reference" xsi:type="NamedTypeSpecifier"/>
                        </source>
                     </source>
                  </operand>
                  <operand localId="342" locator="220:106-220:109" path="value" xsi:type="Property">
                     <source path="id" scope="M" xsi:type="Property"/>
                  </operand>
               </where>
               <return localId="346" locator="221:7-221:25">
                  <expression localId="345" locator="221:14-221:25" path="value" xsi:type="Property">
                     <source path="authoredOn" scope="M" xsi:type="Property"/>
                  </expression>
               </return>
            </then>
            <else xsi:type="As">
               <operand localId="348" locator="223:5-223:8" xsi:type="Null"/>
               <asTypeSpecifier xsi:type="ListTypeSpecifier">
                  <elementType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </asTypeSpecifier>
            </else>
         </expression>
      </def>
      <def localId="354" locator="225:1-226:65" name="Medication Request Period" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="354">
               <a:s>define &quot;Medication Request Period&quot;:
  </a:s>
               <a:s r="353">
                  <a:s r="351">
                     <a:s>CMD</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="353">
                     <a:s>&quot;MedicationRequestPeriod&quot;(</a:s>
                     <a:s r="352">
                        <a:s>&quot;Most Recent Medication Request&quot;</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="353" locator="226:3-226:65" name="MedicationRequestPeriod" libraryName="CMD" xsi:type="FunctionRef">
            <operand localId="352" locator="226:33-226:64" name="Most Recent Medication Request" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="364" locator="228:1-231:10" name="Expected Therapy Length" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="364">
               <a:s>define &quot;Expected Therapy Length&quot;:
  </a:s>
               <a:s r="363">
                  <a:s>convert</a:s>
                  <a:s r="362">
                     <a:s>(
    </a:s>
                     <a:s r="362">
                        <a:s r="355">
                           <a:s>CMD</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="362">
                           <a:s>Quantity(</a:s>
                           <a:s r="360">
                              <a:s>days between </a:s>
                              <a:s r="357">
                                 <a:s>start of </a:s>
                                 <a:s r="356">
                                    <a:s>&quot;Medication Request Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> and </a:s>
                              <a:s r="359">
                                 <a:s>end of </a:s>
                                 <a:s r="358">
                                    <a:s>&quot;Medication Request Period&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="361">
                              <a:s>'d'</a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
                  <a:s> to 'd'</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="363" locator="229:3-231:10" xsi:type="ConvertQuantity">
            <operand localId="362" locator="229:10-231:3" name="Quantity" libraryName="CMD" xsi:type="FunctionRef">
               <operand xsi:type="ToDecimal">
                  <operand localId="360" locator="230:18-230:105" precision="Day" xsi:type="DurationBetween">
                     <operand localId="357" locator="230:31-230:66" xsi:type="Start">
                        <operand localId="356" locator="230:40-230:66" name="Medication Request Period" xsi:type="ExpressionRef"/>
                     </operand>
                     <operand localId="359" locator="230:72-230:105" xsi:type="End">
                        <operand localId="358" locator="230:79-230:105" name="Medication Request Period" xsi:type="ExpressionRef"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="361" locator="230:108-230:110" valueType="t:String" value="d" xsi:type="Literal"/>
            </operand>
            <operand locator="231:8-231:10" valueType="t:String" value="d" xsi:type="Literal"/>
         </expression>
      </def>
      <def localId="367" locator="233:1-234:38" name="Anticipated/actual date of service" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="367">
               <a:s>define &quot;Anticipated/actual date of service&quot;:
  </a:s>
               <a:s r="366">
                  <a:s>start of </a:s>
                  <a:s r="365">
                     <a:s>&quot;Medication Request Period&quot;</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="366" locator="234:3-234:38" xsi:type="Start">
            <operand localId="365" locator="234:12-234:38" name="Medication Request Period" xsi:type="ExpressionRef"/>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorVersion" : "2.7.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "367",
            "s" : [ {
               "value" : [ "","library MBODAInitialExpressions version '0.1.0'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "MBODAInitialExpressions",
         "system" : "http://fhir.org/guides/cqf/us/common",
         "version" : "0.1.0"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "3:1-3:28",
            "localIdentifier" : "USCore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCore" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.1.1'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "2",
            "locator" : "4:1-4:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "2",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIR" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.0.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "6:1-6:37",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/cqf/us/common/FHIRHelpers",
            "version" : "4.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "3",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.1.000'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "4",
            "locator" : "7:1-7:46",
            "localIdentifier" : "UC",
            "path" : "http://fhir.org/guides/cqf/us/common/USCoreCommon",
            "version" : "0.1.0",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "4",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'0.1.0'"," called ","UC" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "5",
            "locator" : "8:1-8:49",
            "localIdentifier" : "UCE",
            "path" : "http://fhir.org/guides/cqf/us/common/USCoreElements",
            "version" : "0.1.0",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "5",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCoreElements" ]
                     } ]
                  }, {
                     "value" : [ " version ","'0.1.0'"," called ","UCE" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "6",
            "locator" : "12:1-12:65",
            "localIdentifier" : "CMD",
            "path" : "http://fhir.org/guides/cqf/us/common/CumulativeMedicationDuration",
            "version" : "3.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "6",
                  "s" : [ {
                     "value" : [ "//CumulativeMedicationDuration was created as part of the US ECQM and CDC Opioid Guideline development \n//http://fhir.org/guides/cdc/opioid-mme-r4\n","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "CumulativeMedicationDuration" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.1.000'"," called ","CMD" ]
                  } ]
               }
            } ]
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "7",
            "locator" : "14:1-14:38",
            "name" : "LOINC",
            "id" : "http://loinc.org",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "7",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"LOINC\"",": ","'http://loinc.org'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "9",
            "locator" : "15:1-15:77",
            "name" : "Body surface area",
            "id" : "8277-6",
            "display" : "Intensive care unit",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "9",
                  "s" : [ {
                     "value" : [ "","code ","\"Body surface area\"",": ","'8277-6'"," from " ]
                  }, {
                     "r" : "8",
                     "s" : [ {
                        "value" : [ "\"LOINC\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Intensive care unit'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "8",
               "locator" : "15:41-15:47",
               "name" : "LOINC"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "locator" : "17:1-17:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "17:1-17:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "17:1-17:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "24",
            "locator" : "19:1-24:3",
            "name" : "Member ID",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "24",
                  "s" : [ {
                     "value" : [ "","define ","\"Member ID\"",":\n  " ]
                  }, {
                     "r" : "23",
                     "s" : [ {
                        "value" : [ "singleton from " ]
                     }, {
                        "r" : "22",
                        "s" : [ {
                           "value" : [ "(\n    " ]
                        }, {
                           "r" : "22",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "11",
                                 "s" : [ {
                                    "r" : "10",
                                    "s" : [ {
                                       "r" : "10",
                                       "s" : [ {
                                          "value" : [ "[","FHIR",".","Coverage","]" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","C" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    " ]
                           }, {
                              "r" : "17",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "17",
                                 "s" : [ {
                                    "value" : [ "EndsWith","(" ]
                                 }, {
                                    "r" : "14",
                                    "s" : [ {
                                       "r" : "13",
                                       "s" : [ {
                                          "r" : "12",
                                          "s" : [ {
                                             "value" : [ "C" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "13",
                                          "s" : [ {
                                             "value" : [ "subscriber" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "14",
                                       "s" : [ {
                                          "value" : [ "reference" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "16",
                                    "s" : [ {
                                       "r" : "15",
                                       "s" : [ {
                                          "value" : [ "Patient" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "16",
                                       "s" : [ {
                                          "value" : [ "id" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    " ]
                           }, {
                              "r" : "21",
                              "s" : [ {
                                 "value" : [ "return " ]
                              }, {
                                 "r" : "20",
                                 "s" : [ {
                                    "r" : "19",
                                    "s" : [ {
                                       "r" : "18",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "19",
                                       "s" : [ {
                                          "value" : [ "subscriberId" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "20",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "23",
               "locator" : "20:3-24:3",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "22",
                  "locator" : "20:18-24:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "11",
                     "locator" : "21:5-21:21",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "10",
                        "locator" : "21:5-21:19",
                        "dataType" : "{http://hl7.org/fhir}Coverage",
                        "templateId" : "http://hl7.org/fhir/StructureDefinition/Coverage",
                        "type" : "Retrieve"
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "17",
                     "locator" : "22:5-22:54",
                     "type" : "EndsWith",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "14",
                           "locator" : "22:20-22:41",
                           "path" : "reference",
                           "type" : "Property",
                           "source" : {
                              "localId" : "13",
                              "locator" : "22:20-22:31",
                              "path" : "subscriber",
                              "scope" : "C",
                              "type" : "Property"
                           }
                        } ]
                     }, {
                        "localId" : "16",
                        "locator" : "22:44-22:53",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "id",
                           "type" : "Property",
                           "source" : {
                              "localId" : "15",
                              "locator" : "22:44-22:50",
                              "name" : "Patient",
                              "type" : "ExpressionRef"
                           }
                        }
                     } ]
                  },
                  "return" : {
                     "localId" : "21",
                     "locator" : "23:5-23:31",
                     "expression" : {
                        "localId" : "20",
                        "locator" : "23:12-23:31",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "19",
                           "locator" : "23:12-23:25",
                           "path" : "subscriberId",
                           "scope" : "C",
                           "type" : "Property"
                        }
                     }
                  }
               }
            }
         }, {
            "localId" : "27",
            "locator" : "26:1-27:35",
            "name" : "Patient Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "27",
                  "s" : [ {
                     "value" : [ "","define ","\"Patient Name\"",":\n  " ]
                  }, {
                     "r" : "26",
                     "s" : [ {
                        "r" : "25",
                        "s" : [ {
                           "value" : [ "UCE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "26",
                        "s" : [ {
                           "value" : [ "\"Name - First Middle(s) Last\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "26",
               "locator" : "27:3-27:35",
               "name" : "Name - First Middle(s) Last",
               "libraryName" : "UCE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "30",
            "locator" : "29:1-30:17",
            "name" : "Last Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "30",
                  "s" : [ {
                     "value" : [ "","define ","\"Last Name\"",":\n  " ]
                  }, {
                     "r" : "29",
                     "s" : [ {
                        "r" : "28",
                        "s" : [ {
                           "value" : [ "UCE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "29",
                        "s" : [ {
                           "value" : [ "\"Last Name\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "29",
               "locator" : "30:3-30:17",
               "name" : "Last Name",
               "libraryName" : "UCE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "33",
            "locator" : "36:1-37:19",
            "name" : "Date of Birth",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "33",
                  "s" : [ {
                     "value" : [ "// TODO: Error: Could not resolve data provider for package 'java.util'.\n// define \"First Name\":\n//   Patient.name.given.first()\n","define ","\"Date of Birth\"",":\n  " ]
                  }, {
                     "r" : "32",
                     "s" : [ {
                        "r" : "31",
                        "s" : [ {
                           "value" : [ "Patient" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "32",
                        "s" : [ {
                           "value" : [ "birthDate" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "32",
               "locator" : "37:3-37:19",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "birthDate",
                  "type" : "Property",
                  "source" : {
                     "localId" : "31",
                     "locator" : "37:3-37:9",
                     "name" : "Patient",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "57",
            "locator" : "39:1-48:3",
            "name" : "Medical Record Number",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "57",
                  "s" : [ {
                     "value" : [ "","define ","\"Medical Record Number\"",":\n  " ]
                  }, {
                     "r" : "56",
                     "s" : [ {
                        "value" : [ "singleton from \n  " ]
                     }, {
                        "r" : "55",
                        "s" : [ {
                           "value" : [ "(\n    " ]
                        }, {
                           "r" : "55",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "45",
                                 "s" : [ {
                                    "r" : "44",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "44",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "35",
                                             "s" : [ {
                                                "r" : "34",
                                                "s" : [ {
                                                   "s" : [ {
                                                      "value" : [ "Patient",".","identifier" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","I" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n      " ]
                                       }, {
                                          "r" : "43",
                                          "s" : [ {
                                             "value" : [ "return " ]
                                          }, {
                                             "r" : "42",
                                             "s" : [ {
                                                "value" : [ "{" ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "value",": " ]
                                                }, {
                                                   "r" : "37",
                                                   "s" : [ {
                                                      "r" : "36",
                                                      "s" : [ {
                                                         "value" : [ "I" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "37",
                                                      "s" : [ {
                                                         "value" : [ "value" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ ", " ]
                                             }, {
                                                "s" : [ {
                                                   "value" : [ "type",": " ]
                                                }, {
                                                   "r" : "41",
                                                   "s" : [ {
                                                      "r" : "40",
                                                      "s" : [ {
                                                         "r" : "39",
                                                         "s" : [ {
                                                            "r" : "38",
                                                            "s" : [ {
                                                               "value" : [ "I" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ "." ]
                                                         }, {
                                                            "r" : "39",
                                                            "s" : [ {
                                                               "value" : [ "type" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "40",
                                                         "s" : [ {
                                                            "value" : [ "codes" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "41",
                                                      "s" : [ {
                                                         "value" : [ "code" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "}" ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n    )" ]
                                    } ]
                                 }, {
                                    "value" : [ " ","valueByTypes" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    // TODO: create code for MR (medical record number)\n    " ]
                           }, {
                              "r" : "51",
                              "s" : [ {
                                 "value" : [ "where " ]
                              }, {
                                 "r" : "51",
                                 "s" : [ {
                                    "r" : "48",
                                    "s" : [ {
                                       "r" : "47",
                                       "s" : [ {
                                          "r" : "46",
                                          "s" : [ {
                                             "value" : [ "UC" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "47",
                                          "s" : [ {
                                             "value" : [ "\"MedicalRecordNumber\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "48",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " in " ]
                                 }, {
                                    "r" : "50",
                                    "s" : [ {
                                       "r" : "49",
                                       "s" : [ {
                                          "value" : [ "valueByTypes" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "50",
                                       "s" : [ {
                                          "value" : [ "type" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    " ]
                           }, {
                              "r" : "54",
                              "s" : [ {
                                 "value" : [ "return " ]
                              }, {
                                 "r" : "53",
                                 "s" : [ {
                                    "r" : "52",
                                    "s" : [ {
                                       "value" : [ "valueByTypes" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "53",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "56",
               "locator" : "40:3-48:3",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "55",
                  "locator" : "41:3-48:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "45",
                     "locator" : "42:5-44:18",
                     "alias" : "valueByTypes",
                     "expression" : {
                        "localId" : "44",
                        "locator" : "42:5-44:5",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "35",
                           "locator" : "42:6-42:25",
                           "alias" : "I",
                           "expression" : {
                              "localId" : "34",
                              "locator" : "42:6-42:23",
                              "path" : "identifier",
                              "type" : "Property",
                              "source" : {
                                 "name" : "Patient",
                                 "type" : "ExpressionRef"
                              }
                           }
                        } ],
                        "relationship" : [ ],
                        "return" : {
                           "localId" : "43",
                           "locator" : "43:7-43:54",
                           "expression" : {
                              "localId" : "42",
                              "locator" : "43:14-43:54",
                              "type" : "Tuple",
                              "element" : [ {
                                 "name" : "value",
                                 "value" : {
                                    "localId" : "37",
                                    "locator" : "43:22-43:28",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "value",
                                       "scope" : "I",
                                       "type" : "Property"
                                    }
                                 }
                              }, {
                                 "name" : "type",
                                 "value" : {
                                    "localId" : "41",
                                    "locator" : "43:37-43:53",
                                    "type" : "Query",
                                    "source" : [ {
                                       "alias" : "$this",
                                       "expression" : {
                                          "localId" : "40",
                                          "locator" : "43:37-43:48",
                                          "path" : "codes",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "39",
                                             "locator" : "43:37-43:42",
                                             "name" : "ToConcept",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "type",
                                                "scope" : "I",
                                                "type" : "Property"
                                             } ]
                                          }
                                       }
                                    } ],
                                    "where" : {
                                       "type" : "Not",
                                       "operand" : {
                                          "type" : "IsNull",
                                          "operand" : {
                                             "path" : "code",
                                             "type" : "Property",
                                             "source" : {
                                                "name" : "$this",
                                                "type" : "AliasRef"
                                             }
                                          }
                                       }
                                    },
                                    "return" : {
                                       "distinct" : false,
                                       "expression" : {
                                          "path" : "code",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "$this",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    }
                                 }
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "51",
                     "locator" : "46:5-46:60",
                     "type" : "In",
                     "operand" : [ {
                        "localId" : "48",
                        "locator" : "46:11-46:39",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "47",
                           "locator" : "46:11-46:34",
                           "name" : "MedicalRecordNumber",
                           "libraryName" : "UC",
                           "type" : "CodeRef"
                        }
                     }, {
                        "localId" : "50",
                        "locator" : "46:44-46:60",
                        "path" : "type",
                        "scope" : "valueByTypes",
                        "type" : "Property"
                     } ]
                  },
                  "return" : {
                     "localId" : "54",
                     "locator" : "47:5-47:29",
                     "expression" : {
                        "localId" : "53",
                        "locator" : "47:12-47:29",
                        "path" : "value",
                        "scope" : "valueByTypes",
                        "type" : "Property"
                     }
                  }
               }
            }
         }, {
            "localId" : "63",
            "locator" : "50:1-51:34",
            "name" : "Phone Number",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "63",
                  "s" : [ {
                     "value" : [ "","define ","\"Phone Number\"",":\n  " ]
                  }, {
                     "r" : "62",
                     "s" : [ {
                        "r" : "61",
                        "s" : [ {
                           "r" : "58",
                           "s" : [ {
                              "value" : [ "UC" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "61",
                           "s" : [ {
                              "value" : [ "Mobile","(" ]
                           }, {
                              "r" : "60",
                              "s" : [ {
                                 "r" : "59",
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "60",
                                 "s" : [ {
                                    "value" : [ "telecom" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "62",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "62",
               "locator" : "51:3-51:34",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "localId" : "61",
                     "locator" : "51:3-51:28",
                     "name" : "Mobile",
                     "libraryName" : "UC",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "60",
                        "locator" : "51:13-51:27",
                        "path" : "telecom",
                        "type" : "Property",
                        "source" : {
                           "localId" : "59",
                           "locator" : "51:13-51:19",
                           "name" : "Patient",
                           "type" : "ExpressionRef"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "70",
            "locator" : "53:1-55:17",
            "name" : "Allergies",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "70",
                  "s" : [ {
                     "value" : [ "","define ","\"Allergies\"",":\n  " ]
                  }, {
                     "r" : "69",
                     "s" : [ {
                        "s" : [ {
                           "r" : "65",
                           "s" : [ {
                              "r" : "64",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "UCE",".","\"Active Confirmed Allergies and Intolerances\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","A" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "68",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "67",
                           "s" : [ {
                              "r" : "66",
                              "s" : [ {
                                 "value" : [ "A" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "67",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "69",
               "locator" : "54:3-55:17",
               "type" : "Query",
               "source" : [ {
                  "localId" : "65",
                  "locator" : "54:3-54:53",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "64",
                     "locator" : "54:3-54:51",
                     "name" : "Active Confirmed Allergies and Intolerances",
                     "libraryName" : "UCE",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "68",
                  "locator" : "55:5-55:17",
                  "expression" : {
                     "localId" : "67",
                     "locator" : "55:12-55:17",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "code",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  }
               }
            }
         }, {
            "localId" : "73",
            "locator" : "60:1-61:39",
            "name" : "Address",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "73",
                  "s" : [ {
                     "value" : [ "// TODO: Error: Could not resolve data provider for package 'java.util'.\n// define \"Address\":\n//   (singleton from Patient.address).line\n","define ","\"Address\"",":\n  " ]
                  }, {
                     "r" : "72",
                     "s" : [ {
                        "value" : [ "{ " ]
                     }, {
                        "r" : "71",
                        "s" : [ {
                           "value" : [ "'TODO: remove hard-coded address'" ]
                        } ]
                     }, {
                        "value" : [ " }" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "72",
               "locator" : "61:3-61:39",
               "type" : "List",
               "element" : [ {
                  "localId" : "71",
                  "locator" : "61:5-61:37",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "TODO: remove hard-coded address",
                  "type" : "Literal"
               } ]
            }
         }, {
            "localId" : "77",
            "locator" : "63:1-64:22",
            "name" : "City",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "77",
                  "s" : [ {
                     "value" : [ "","define ","\"City\"",":\n  " ]
                  }, {
                     "r" : "76",
                     "s" : [ {
                        "r" : "75",
                        "s" : [ {
                           "r" : "74",
                           "s" : [ {
                              "value" : [ "Patient" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "75",
                           "s" : [ {
                              "value" : [ "address" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "76",
                        "s" : [ {
                           "value" : [ "city" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "76",
               "locator" : "64:3-64:22",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "75",
                     "locator" : "64:3-64:17",
                     "path" : "address",
                     "type" : "Property",
                     "source" : {
                        "localId" : "74",
                        "locator" : "64:3-64:9",
                        "name" : "Patient",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "city",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        }
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "city",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               }
            }
         }, {
            "localId" : "81",
            "locator" : "66:1-67:23",
            "name" : "State",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "81",
                  "s" : [ {
                     "value" : [ "","define ","\"State\"",":\n  " ]
                  }, {
                     "r" : "80",
                     "s" : [ {
                        "r" : "79",
                        "s" : [ {
                           "r" : "78",
                           "s" : [ {
                              "value" : [ "Patient" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "79",
                           "s" : [ {
                              "value" : [ "address" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "80",
                        "s" : [ {
                           "value" : [ "state" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "80",
               "locator" : "67:3-67:23",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "79",
                     "locator" : "67:3-67:17",
                     "path" : "address",
                     "type" : "Property",
                     "source" : {
                        "localId" : "78",
                        "locator" : "67:3-67:9",
                        "name" : "Patient",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "state",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        }
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "state",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               }
            }
         }, {
            "localId" : "85",
            "locator" : "69:1-70:28",
            "name" : "Zip",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "85",
                  "s" : [ {
                     "value" : [ "","define ","\"Zip\"",":\n  " ]
                  }, {
                     "r" : "84",
                     "s" : [ {
                        "r" : "83",
                        "s" : [ {
                           "r" : "82",
                           "s" : [ {
                              "value" : [ "Patient" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "83",
                           "s" : [ {
                              "value" : [ "address" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "84",
                        "s" : [ {
                           "value" : [ "postalCode" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "84",
               "locator" : "70:3-70:28",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "83",
                     "locator" : "70:3-70:17",
                     "path" : "address",
                     "type" : "Property",
                     "source" : {
                        "localId" : "82",
                        "locator" : "70:3-70:9",
                        "name" : "Patient",
                        "type" : "ExpressionRef"
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "postalCode",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        }
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "postalCode",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               }
            }
         }, {
            "localId" : "93",
            "locator" : "72:1-77:15",
            "name" : "Height",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "93",
                  "s" : [ {
                     "value" : [ "","define ","\"Height\"",":\n  " ]
                  }, {
                     "r" : "92",
                     "s" : [ {
                        "value" : [ "convert" ]
                     }, {
                        "r" : "91",
                        "s" : [ {
                           "value" : [ "(\n    " ]
                        }, {
                           "r" : "91",
                           "s" : [ {
                              "r" : "90",
                              "s" : [ {
                                 "r" : "86",
                                 "s" : [ {
                                    "value" : [ "UC" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "90",
                                 "s" : [ {
                                    "value" : [ "MostRecent","(\n      " ]
                                 }, {
                                    "r" : "89",
                                    "s" : [ {
                                       "r" : "88",
                                       "s" : [ {
                                          "r" : "87",
                                          "s" : [ {
                                             "value" : [ "UCE" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "88",
                                          "s" : [ {
                                             "value" : [ "\"All Body Height Measurements\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "89",
                                       "s" : [ {
                                          "value" : [ "resulted","()" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    )" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "91",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " \n  )" ]
                        } ]
                     }, {
                        "value" : [ " to ","'[in_i]'" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "92",
               "locator" : "73:3-77:15",
               "type" : "ConvertQuantity",
               "operand" : [ {
                  "localId" : "91",
                  "locator" : "73:10-77:3",
                  "name" : "ToQuantity",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "90",
                        "locator" : "74:5-76:5",
                        "name" : "MostRecent",
                        "libraryName" : "UC",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "89",
                           "locator" : "75:7-75:51",
                           "name" : "resulted",
                           "libraryName" : "UC",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "88",
                              "locator" : "75:7-75:40",
                              "name" : "All Body Height Measurements",
                              "libraryName" : "UCE",
                              "type" : "ExpressionRef"
                           } ]
                        } ]
                     }
                  } ]
               }, {
                  "locator" : "77:8-77:15",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "[in_i]",
                  "type" : "Literal"
               } ]
            }
         }, {
            "localId" : "96",
            "locator" : "79:1-80:16",
            "name" : "Height in [in_i]",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "96",
                  "s" : [ {
                     "value" : [ "","define ","\"Height in [in_i]\"",":\n  " ]
                  }, {
                     "r" : "95",
                     "s" : [ {
                        "r" : "94",
                        "s" : [ {
                           "value" : [ "\"Height\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "95",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "95",
               "locator" : "80:3-80:16",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "94",
                  "locator" : "80:3-80:10",
                  "name" : "Height",
                  "type" : "ExpressionRef"
               }
            }
         }, {
            "localId" : "104",
            "locator" : "82:1-87:16",
            "name" : "Weight",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "104",
                  "s" : [ {
                     "value" : [ "","define ","\"Weight\"",":\n  " ]
                  }, {
                     "r" : "103",
                     "s" : [ {
                        "value" : [ "convert" ]
                     }, {
                        "r" : "102",
                        "s" : [ {
                           "value" : [ "(\n    " ]
                        }, {
                           "r" : "102",
                           "s" : [ {
                              "r" : "101",
                              "s" : [ {
                                 "r" : "97",
                                 "s" : [ {
                                    "value" : [ "UC" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "101",
                                 "s" : [ {
                                    "value" : [ "MostRecent","(\n      " ]
                                 }, {
                                    "r" : "100",
                                    "s" : [ {
                                       "r" : "99",
                                       "s" : [ {
                                          "r" : "98",
                                          "s" : [ {
                                             "value" : [ "UCE" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "99",
                                          "s" : [ {
                                             "value" : [ "\"All Body Weight Measurements\"" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "100",
                                       "s" : [ {
                                          "value" : [ "resulted","()" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    )" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "102",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " \n  )" ]
                        } ]
                     }, {
                        "value" : [ " to ","'[lb_av]'" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "103",
               "locator" : "83:3-87:16",
               "type" : "ConvertQuantity",
               "operand" : [ {
                  "localId" : "102",
                  "locator" : "83:10-87:3",
                  "name" : "ToQuantity",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "localId" : "101",
                        "locator" : "84:5-86:5",
                        "name" : "MostRecent",
                        "libraryName" : "UC",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "100",
                           "locator" : "85:7-85:51",
                           "name" : "resulted",
                           "libraryName" : "UC",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "99",
                              "locator" : "85:7-85:40",
                              "name" : "All Body Weight Measurements",
                              "libraryName" : "UCE",
                              "type" : "ExpressionRef"
                           } ]
                        } ]
                     }
                  } ]
               }, {
                  "locator" : "87:8-87:16",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "[lb_av]",
                  "type" : "Literal"
               } ]
            }
         }, {
            "localId" : "107",
            "locator" : "89:1-90:16",
            "name" : "Weight in [lb_av]",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "107",
                  "s" : [ {
                     "value" : [ "","define ","\"Weight in [lb_av]\"",":\n  " ]
                  }, {
                     "r" : "106",
                     "s" : [ {
                        "r" : "105",
                        "s" : [ {
                           "value" : [ "\"Weight\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "106",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "106",
               "locator" : "90:3-90:16",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "105",
                  "locator" : "90:3-90:10",
                  "name" : "Weight",
                  "type" : "ExpressionRef"
               }
            }
         }, {
            "localId" : "135",
            "locator" : "92:1-101:11",
            "name" : "Most Recent BSA",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "135",
                  "s" : [ {
                     "value" : [ "","define ","\"Most Recent BSA\"",":\n  " ]
                  }, {
                     "r" : "134",
                     "s" : [ {
                        "value" : [ "convert" ]
                     }, {
                        "r" : "133",
                        "s" : [ {
                           "value" : [ "( \n    " ]
                        }, {
                           "r" : "133",
                           "s" : [ {
                              "r" : "132",
                              "s" : [ {
                                 "r" : "108",
                                 "s" : [ {
                                    "value" : [ "UC" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "132",
                                 "s" : [ {
                                    "value" : [ "MostRecent","(\n      " ]
                                 }, {
                                    "r" : "131",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "131",
                                       "s" : [ {
                                          "s" : [ {
                                             "r" : "110",
                                             "s" : [ {
                                                "r" : "109",
                                                "s" : [ {
                                                   "r" : "109",
                                                   "s" : [ {
                                                      "value" : [ "[","FHIR",".","Observation",": " ]
                                                   }, {
                                                      "s" : [ {
                                                         "value" : [ "\"Body surface area\"" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "]" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " ","observation" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "\n        " ]
                                       }, {
                                          "r" : "130",
                                          "s" : [ {
                                             "value" : [ "where " ]
                                          }, {
                                             "r" : "130",
                                             "s" : [ {
                                                "r" : "123",
                                                "s" : [ {
                                                   "r" : "116",
                                                   "s" : [ {
                                                      "r" : "112",
                                                      "s" : [ {
                                                         "r" : "111",
                                                         "s" : [ {
                                                            "value" : [ "observation" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "112",
                                                         "s" : [ {
                                                            "value" : [ "status" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " ","~"," " ]
                                                   }, {
                                                      "r" : "115",
                                                      "s" : [ {
                                                         "r" : "114",
                                                         "s" : [ {
                                                            "r" : "113",
                                                            "s" : [ {
                                                               "value" : [ "UC" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ "." ]
                                                         }, {
                                                            "r" : "114",
                                                            "s" : [ {
                                                               "value" : [ "\"observation-final\"" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "115",
                                                         "s" : [ {
                                                            "value" : [ "code" ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "\n          or " ]
                                                }, {
                                                   "r" : "122",
                                                   "s" : [ {
                                                      "r" : "118",
                                                      "s" : [ {
                                                         "r" : "117",
                                                         "s" : [ {
                                                            "value" : [ "observation" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "118",
                                                         "s" : [ {
                                                            "value" : [ "status" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " ","~"," " ]
                                                   }, {
                                                      "r" : "121",
                                                      "s" : [ {
                                                         "r" : "120",
                                                         "s" : [ {
                                                            "r" : "119",
                                                            "s" : [ {
                                                               "value" : [ "UC" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ "." ]
                                                         }, {
                                                            "r" : "120",
                                                            "s" : [ {
                                                               "value" : [ "\"observation-amended\"" ]
                                                            } ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "121",
                                                         "s" : [ {
                                                            "value" : [ "code" ]
                                                         } ]
                                                      } ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "\n          or " ]
                                             }, {
                                                "r" : "129",
                                                "s" : [ {
                                                   "r" : "125",
                                                   "s" : [ {
                                                      "r" : "124",
                                                      "s" : [ {
                                                         "value" : [ "observation" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "125",
                                                      "s" : [ {
                                                         "value" : [ "status" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ " ","~"," " ]
                                                }, {
                                                   "r" : "128",
                                                   "s" : [ {
                                                      "r" : "127",
                                                      "s" : [ {
                                                         "r" : "126",
                                                         "s" : [ {
                                                            "value" : [ "UC" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ "." ]
                                                      }, {
                                                         "r" : "127",
                                                         "s" : [ {
                                                            "value" : [ "\"observation-corrected\"" ]
                                                         } ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "128",
                                                      "s" : [ {
                                                         "value" : [ "code" ]
                                                      } ]
                                                   } ]
                                                } ]
                                             } ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n      )" ]
                                    } ]
                                 }, {
                                    "value" : [ "\n    )" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "133",
                              "s" : [ {
                                 "value" : [ "value" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " \n  )" ]
                        } ]
                     }, {
                        "value" : [ " to ","'m2'" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "134",
               "locator" : "93:3-101:11",
               "type" : "ConvertQuantity",
               "operand" : [ {
                  "name" : "ToQuantity",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "asType" : "{http://hl7.org/fhir}Quantity",
                     "type" : "As",
                     "operand" : {
                        "localId" : "133",
                        "locator" : "93:10-101:3",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "localId" : "132",
                           "locator" : "94:5-100:5",
                           "name" : "MostRecent",
                           "libraryName" : "UC",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "localId" : "131",
                              "locator" : "95:7-99:7",
                              "type" : "Query",
                              "source" : [ {
                                 "localId" : "110",
                                 "locator" : "95:8-95:58",
                                 "alias" : "observation",
                                 "expression" : {
                                    "localId" : "109",
                                    "locator" : "95:8-95:46",
                                    "dataType" : "{http://hl7.org/fhir}Observation",
                                    "templateId" : "http://hl7.org/fhir/StructureDefinition/Observation",
                                    "codeProperty" : "code",
                                    "codeComparator" : "~",
                                    "type" : "Retrieve",
                                    "codes" : {
                                       "type" : "ToList",
                                       "operand" : {
                                          "locator" : "95:27-95:45",
                                          "name" : "Body surface area",
                                          "type" : "CodeRef"
                                       }
                                    }
                                 }
                              } ],
                              "relationship" : [ ],
                              "where" : {
                                 "localId" : "130",
                                 "locator" : "96:9-98:65",
                                 "type" : "Or",
                                 "operand" : [ {
                                    "localId" : "123",
                                    "locator" : "96:15-97:63",
                                    "type" : "Or",
                                    "operand" : [ {
                                       "localId" : "116",
                                       "locator" : "96:15-96:62",
                                       "type" : "Equivalent",
                                       "operand" : [ {
                                          "name" : "ToString",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "112",
                                             "locator" : "96:15-96:32",
                                             "path" : "status",
                                             "scope" : "observation",
                                             "type" : "Property"
                                          } ]
                                       }, {
                                          "localId" : "115",
                                          "locator" : "96:36-96:62",
                                          "path" : "code",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "114",
                                             "locator" : "96:36-96:57",
                                             "name" : "observation-final",
                                             "libraryName" : "UC",
                                             "type" : "CodeRef"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "122",
                                       "locator" : "97:14-97:63",
                                       "type" : "Equivalent",
                                       "operand" : [ {
                                          "name" : "ToString",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "localId" : "118",
                                             "locator" : "97:14-97:31",
                                             "path" : "status",
                                             "scope" : "observation",
                                             "type" : "Property"
                                          } ]
                                       }, {
                                          "localId" : "121",
                                          "locator" : "97:35-97:63",
                                          "path" : "code",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "120",
                                             "locator" : "97:35-97:58",
                                             "name" : "observation-amended",
                                             "libraryName" : "UC",
                                             "type" : "CodeRef"
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "129",
                                    "locator" : "98:14-98:65",
                                    "type" : "Equivalent",
                                    "operand" : [ {
                                       "name" : "ToString",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "125",
                                          "locator" : "98:14-98:31",
                                          "path" : "status",
                                          "scope" : "observation",
                                          "type" : "Property"
                                       } ]
                                    }, {
                                       "localId" : "128",
                                       "locator" : "98:35-98:65",
                                       "path" : "code",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "127",
                                          "locator" : "98:35-98:60",
                                          "name" : "observation-corrected",
                                          "libraryName" : "UC",
                                          "type" : "CodeRef"
                                       }
                                    } ]
                                 } ]
                              }
                           } ]
                        }
                     }
                  } ]
               }, {
                  "locator" : "101:8-101:11",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "m2",
                  "type" : "Literal"
               } ]
            }
         }, {
            "localId" : "177",
            "locator" : "123:1-137:3",
            "name" : "CalculateBSA",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "177",
                  "s" : [ {
                     "value" : [ "","define function ","CalculateBSA","(","alg"," " ]
                  }, {
                     "r" : "140",
                     "s" : [ {
                        "value" : [ "System",".","String" ]
                     } ]
                  }, {
                     "value" : [ ", ","height"," " ]
                  }, {
                     "r" : "141",
                     "s" : [ {
                        "value" : [ "System",".","Quantity" ]
                     } ]
                  }, {
                     "value" : [ ", ","weight"," " ]
                  }, {
                     "r" : "142",
                     "s" : [ {
                        "value" : [ "System",".","Quantity" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "176",
                     "s" : [ {
                        "r" : "176",
                        "s" : [ {
                           "value" : [ "System",".","Quantity"," { " ]
                        }, {
                           "s" : [ {
                              "value" : [ "value",": \n    // Mosteller formula using lbs and inches\n    " ]
                           }, {
                              "r" : "174",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "145",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "145",
                                    "s" : [ {
                                       "r" : "143",
                                       "s" : [ {
                                          "value" : [ "alg" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","="," " ]
                                    }, {
                                       "r" : "144",
                                       "s" : [ {
                                          "value" : [ "'Mosteller'" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ " then\n      " ]
                              }, {
                                 "r" : "155",
                                 "s" : [ {
                                    "r" : "153",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "153",
                                       "s" : [ {
                                          "r" : "152",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "152",
                                             "s" : [ {
                                                "r" : "150",
                                                "s" : [ {
                                                   "value" : [ "(" ]
                                                }, {
                                                   "r" : "150",
                                                   "s" : [ {
                                                      "r" : "147",
                                                      "s" : [ {
                                                         "value" : [ "(" ]
                                                      }, {
                                                         "r" : "147",
                                                         "s" : [ {
                                                            "value" : [ "convert" ]
                                                         }, {
                                                            "r" : "146",
                                                            "s" : [ {
                                                               "value" : [ "(" ]
                                                            }, {
                                                               "r" : "146",
                                                               "s" : [ {
                                                                  "value" : [ "height" ]
                                                               } ]
                                                            }, {
                                                               "value" : [ ")" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " to ","'[in_i]'" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " * " ]
                                                   }, {
                                                      "r" : "149",
                                                      "s" : [ {
                                                         "value" : [ "(" ]
                                                      }, {
                                                         "r" : "149",
                                                         "s" : [ {
                                                            "value" : [ "convert" ]
                                                         }, {
                                                            "r" : "148",
                                                            "s" : [ {
                                                               "value" : [ "(" ]
                                                            }, {
                                                               "r" : "148",
                                                               "s" : [ {
                                                                  "value" : [ "weight" ]
                                                               } ]
                                                            }, {
                                                               "value" : [ ")" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ " to ","'[lb_av]'" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             }, {
                                                "r" : "151",
                                                "value" : [ "/","3131" ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "153",
                                          "s" : [ {
                                             "value" : [ "value" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "r" : "154",
                                    "value" : [ "^","0.5" ]
                                 } ]
                              }, {
                                 "value" : [ "\n    \n    // DuBois and DuBois formula using cm and kg\n    // NOTE: never to be used for newborn calculation\n    else " ]
                              }, {
                                 "r" : "173",
                                 "s" : [ {
                                    "value" : [ "if " ]
                                 }, {
                                    "r" : "158",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "158",
                                       "s" : [ {
                                          "r" : "156",
                                          "s" : [ {
                                             "value" : [ "alg" ]
                                          } ]
                                       }, {
                                          "value" : [ " ","="," " ]
                                       }, {
                                          "r" : "157",
                                          "s" : [ {
                                             "value" : [ "'DuBois and DuBois'" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ " then\n      " ]
                                 }, {
                                    "r" : "171",
                                    "s" : [ {
                                       "r" : "165",
                                       "s" : [ {
                                          "r" : "159",
                                          "value" : [ "0.007184"," * " ]
                                       }, {
                                          "r" : "164",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "164",
                                             "s" : [ {
                                                "r" : "162",
                                                "s" : [ {
                                                   "r" : "161",
                                                   "s" : [ {
                                                      "value" : [ "(" ]
                                                   }, {
                                                      "r" : "161",
                                                      "s" : [ {
                                                         "value" : [ "convert" ]
                                                      }, {
                                                         "r" : "160",
                                                         "s" : [ {
                                                            "value" : [ "(" ]
                                                         }, {
                                                            "r" : "160",
                                                            "s" : [ {
                                                               "value" : [ "height" ]
                                                            } ]
                                                         }, {
                                                            "value" : [ ")" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ " to ","'cm'" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ ")" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "162",
                                                   "s" : [ {
                                                      "value" : [ "value" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "r" : "163",
                                                "value" : [ "^","0.725" ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " * " ]
                                    }, {
                                       "r" : "170",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "170",
                                          "s" : [ {
                                             "r" : "168",
                                             "s" : [ {
                                                "r" : "167",
                                                "s" : [ {
                                                   "value" : [ "(" ]
                                                }, {
                                                   "r" : "167",
                                                   "s" : [ {
                                                      "value" : [ "convert" ]
                                                   }, {
                                                      "r" : "166",
                                                      "s" : [ {
                                                         "value" : [ "(" ]
                                                      }, {
                                                         "r" : "166",
                                                         "s" : [ {
                                                            "value" : [ "weight" ]
                                                         } ]
                                                      }, {
                                                         "value" : [ ")" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ " to ","'kg'" ]
                                                   } ]
                                                }, {
                                                   "value" : [ ")" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "168",
                                                "s" : [ {
                                                   "value" : [ "value" ]
                                                } ]
                                             } ]
                                          }, {
                                             "r" : "169",
                                             "value" : [ "^","0.425" ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "r" : "172",
                                    "value" : [ "\n    \n    // No matching algorithm found\n    else ","null" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ",\n    " ]
                        }, {
                           "s" : [ {
                              "value" : [ "unit",": " ]
                           }, {
                              "r" : "175",
                              "s" : [ {
                                 "value" : [ "'m2'" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  }" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "176",
               "locator" : "124:3-137:3",
               "classType" : "{urn:hl7-org:elm-types:r1}Quantity",
               "type" : "Instance",
               "element" : [ {
                  "name" : "value",
                  "value" : {
                     "localId" : "174",
                     "locator" : "126:5-135:13",
                     "type" : "If",
                     "condition" : {
                        "localId" : "145",
                        "locator" : "126:8-126:26",
                        "type" : "Equal",
                        "operand" : [ {
                           "localId" : "143",
                           "locator" : "126:9-126:11",
                           "name" : "alg",
                           "type" : "OperandRef"
                        }, {
                           "localId" : "144",
                           "locator" : "126:15-126:25",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "Mosteller",
                           "type" : "Literal"
                        } ]
                     },
                     "then" : {
                        "localId" : "155",
                        "locator" : "127:7-127:89",
                        "type" : "Power",
                        "operand" : [ {
                           "localId" : "153",
                           "locator" : "127:7-127:85",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "152",
                              "locator" : "127:8-127:78",
                              "type" : "Divide",
                              "operand" : [ {
                                 "localId" : "150",
                                 "locator" : "127:9-127:72",
                                 "type" : "Multiply",
                                 "operand" : [ {
                                    "localId" : "147",
                                    "locator" : "127:10-127:38",
                                    "type" : "ConvertQuantity",
                                    "operand" : [ {
                                       "localId" : "146",
                                       "locator" : "127:18-127:25",
                                       "name" : "height",
                                       "type" : "OperandRef"
                                    }, {
                                       "locator" : "127:30-127:37",
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "[in_i]",
                                       "type" : "Literal"
                                    } ]
                                 }, {
                                    "localId" : "149",
                                    "locator" : "127:42-127:71",
                                    "type" : "ConvertQuantity",
                                    "operand" : [ {
                                       "localId" : "148",
                                       "locator" : "127:50-127:57",
                                       "name" : "weight",
                                       "type" : "OperandRef"
                                    }, {
                                       "locator" : "127:62-127:70",
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "[lb_av]",
                                       "type" : "Literal"
                                    } ]
                                 } ]
                              }, {
                                 "type" : "ToQuantity",
                                 "operand" : {
                                    "localId" : "151",
                                    "locator" : "127:74-127:77",
                                    "valueType" : "{urn:hl7-org:elm-types:r1}Integer",
                                    "value" : "3131",
                                    "type" : "Literal"
                                 }
                              } ]
                           }
                        }, {
                           "localId" : "154",
                           "locator" : "127:87-127:89",
                           "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                           "value" : "0.5",
                           "type" : "Literal"
                        } ]
                     },
                     "else" : {
                        "localId" : "173",
                        "locator" : "131:10-135:13",
                        "type" : "If",
                        "condition" : {
                           "localId" : "158",
                           "locator" : "131:13-131:39",
                           "type" : "Equal",
                           "operand" : [ {
                              "localId" : "156",
                              "locator" : "131:14-131:16",
                              "name" : "alg",
                              "type" : "OperandRef"
                           }, {
                              "localId" : "157",
                              "locator" : "131:20-131:38",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "DuBois and DuBois",
                              "type" : "Literal"
                           } ]
                        },
                        "then" : {
                           "localId" : "171",
                           "locator" : "132:7-132:98",
                           "type" : "Multiply",
                           "operand" : [ {
                              "localId" : "165",
                              "locator" : "132:7-132:56",
                              "type" : "Multiply",
                              "operand" : [ {
                                 "localId" : "159",
                                 "locator" : "132:7-132:14",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                                 "value" : "0.007184",
                                 "type" : "Literal"
                              }, {
                                 "localId" : "164",
                                 "locator" : "132:18-132:56",
                                 "type" : "Power",
                                 "operand" : [ {
                                    "localId" : "162",
                                    "locator" : "132:19-132:49",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "161",
                                       "locator" : "132:19-132:43",
                                       "type" : "ConvertQuantity",
                                       "operand" : [ {
                                          "localId" : "160",
                                          "locator" : "132:27-132:34",
                                          "name" : "height",
                                          "type" : "OperandRef"
                                       }, {
                                          "locator" : "132:39-132:42",
                                          "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                          "value" : "cm",
                                          "type" : "Literal"
                                       } ]
                                    }
                                 }, {
                                    "localId" : "163",
                                    "locator" : "132:51-132:55",
                                    "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                                    "value" : "0.725",
                                    "type" : "Literal"
                                 } ]
                              } ]
                           }, {
                              "localId" : "170",
                              "locator" : "132:60-132:98",
                              "type" : "Power",
                              "operand" : [ {
                                 "localId" : "168",
                                 "locator" : "132:61-132:91",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "167",
                                    "locator" : "132:61-132:85",
                                    "type" : "ConvertQuantity",
                                    "operand" : [ {
                                       "localId" : "166",
                                       "locator" : "132:69-132:76",
                                       "name" : "weight",
                                       "type" : "OperandRef"
                                    }, {
                                       "locator" : "132:81-132:84",
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "kg",
                                       "type" : "Literal"
                                    } ]
                                 }
                              }, {
                                 "localId" : "169",
                                 "locator" : "132:93-132:97",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}Decimal",
                                 "value" : "0.425",
                                 "type" : "Literal"
                              } ]
                           } ]
                        },
                        "else" : {
                           "asType" : "{urn:hl7-org:elm-types:r1}Decimal",
                           "type" : "As",
                           "operand" : {
                              "localId" : "172",
                              "locator" : "135:10-135:13",
                              "type" : "Null"
                           }
                        }
                     }
                  }
               }, {
                  "name" : "unit",
                  "value" : {
                     "localId" : "175",
                     "locator" : "136:11-136:14",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "m2",
                     "type" : "Literal"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "alg",
               "operandTypeSpecifier" : {
                  "localId" : "140",
                  "locator" : "123:34-123:46",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "height",
               "operandTypeSpecifier" : {
                  "localId" : "141",
                  "locator" : "123:56-123:70",
                  "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "weight",
               "operandTypeSpecifier" : {
                  "localId" : "142",
                  "locator" : "123:80-123:94",
                  "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "179",
            "locator" : "110:1-111:47",
            "name" : "Calculated BSA - Mosteller",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "179",
                  "s" : [ {
                     "value" : [ "// Mosteller formula using lbs and inches\n","define ","\"Calculated BSA - Mosteller\"",":\n  " ]
                  }, {
                     "r" : "178",
                     "s" : [ {
                        "value" : [ "CalculateBSA","(" ]
                     }, {
                        "r" : "137",
                        "s" : [ {
                           "value" : [ "'Mosteller'" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "138",
                        "s" : [ {
                           "value" : [ "\"Height\"" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "139",
                        "s" : [ {
                           "value" : [ "\"Weight\"" ]
                        } ]
                     }, {
                        "value" : [ ")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "178",
               "locator" : "111:3-111:47",
               "name" : "CalculateBSA",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "137",
                  "locator" : "111:16-111:26",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "Mosteller",
                  "type" : "Literal"
               }, {
                  "localId" : "138",
                  "locator" : "111:29-111:36",
                  "name" : "Height",
                  "type" : "ExpressionRef"
               }, {
                  "localId" : "139",
                  "locator" : "111:39-111:46",
                  "name" : "Weight",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "182",
            "locator" : "103:1-104:59",
            "name" : "BSA",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "182",
                  "s" : [ {
                     "value" : [ "","define ","\"BSA\"",":\n  " ]
                  }, {
                     "r" : "181",
                     "s" : [ {
                        "value" : [ "Coalesce","(" ]
                     }, {
                        "r" : "136",
                        "s" : [ {
                           "value" : [ "\"Most Recent BSA\"" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "180",
                        "s" : [ {
                           "value" : [ "\"Calculated BSA - Mosteller\"" ]
                        } ]
                     }, {
                        "value" : [ ")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "181",
               "locator" : "104:3-104:59",
               "type" : "Coalesce",
               "operand" : [ {
                  "localId" : "136",
                  "locator" : "104:12-104:28",
                  "name" : "Most Recent BSA",
                  "type" : "ExpressionRef"
               }, {
                  "localId" : "180",
                  "locator" : "104:31-104:58",
                  "name" : "Calculated BSA - Mosteller",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "185",
            "locator" : "106:1-107:13",
            "name" : "BSA in m2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "185",
                  "s" : [ {
                     "value" : [ "","define ","\"BSA in m2\"",":\n  " ]
                  }, {
                     "r" : "184",
                     "s" : [ {
                        "r" : "183",
                        "s" : [ {
                           "value" : [ "\"BSA\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "184",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "184",
               "locator" : "107:3-107:13",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "localId" : "183",
                  "locator" : "107:3-107:7",
                  "name" : "BSA",
                  "type" : "ExpressionRef"
               }
            }
         }, {
            "localId" : "188",
            "locator" : "114:1-115:27",
            "name" : "Height in cm",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "188",
                  "s" : [ {
                     "value" : [ "//(((\"Weight\"*\"Height\")/3131).value)^0.5\n","define ","\"Height in cm\"",":\n  " ]
                  }, {
                     "r" : "187",
                     "s" : [ {
                        "value" : [ "convert" ]
                     }, {
                        "r" : "186",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "186",
                           "s" : [ {
                              "value" : [ "\"Height\"" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "value" : [ " to ","'cm'" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "187",
               "locator" : "115:3-115:27",
               "type" : "ConvertQuantity",
               "operand" : [ {
                  "localId" : "186",
                  "locator" : "115:10-115:19",
                  "name" : "Height",
                  "type" : "ExpressionRef"
               }, {
                  "locator" : "115:24-115:27",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "cm",
                  "type" : "Literal"
               } ]
            }
         }, {
            "localId" : "191",
            "locator" : "117:1-118:27",
            "name" : "Weight in kg",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "191",
                  "s" : [ {
                     "value" : [ "","define ","\"Weight in kg\"",":\n  " ]
                  }, {
                     "r" : "190",
                     "s" : [ {
                        "value" : [ "convert" ]
                     }, {
                        "r" : "189",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "189",
                           "s" : [ {
                              "value" : [ "\"Weight\"" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "value" : [ " to ","'kg'" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "190",
               "locator" : "118:3-118:27",
               "type" : "ConvertQuantity",
               "operand" : [ {
                  "localId" : "189",
                  "locator" : "118:10-118:19",
                  "name" : "Weight",
                  "type" : "ExpressionRef"
               }, {
                  "locator" : "118:24-118:27",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "kg",
                  "type" : "Literal"
               } ]
            }
         }, {
            "localId" : "196",
            "locator" : "120:1-121:55",
            "name" : "Calculated BSA - DuBois and DuBois",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "196",
                  "s" : [ {
                     "value" : [ "","define ","\"Calculated BSA - DuBois and DuBois\"",":\n  " ]
                  }, {
                     "r" : "195",
                     "s" : [ {
                        "value" : [ "CalculateBSA","(" ]
                     }, {
                        "r" : "192",
                        "s" : [ {
                           "value" : [ "'DuBois and DuBois'" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "193",
                        "s" : [ {
                           "value" : [ "\"Height\"" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "194",
                        "s" : [ {
                           "value" : [ "\"Weight\"" ]
                        } ]
                     }, {
                        "value" : [ ")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "195",
               "locator" : "121:3-121:55",
               "name" : "CalculateBSA",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "192",
                  "locator" : "121:16-121:34",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "DuBois and DuBois",
                  "type" : "Literal"
               }, {
                  "localId" : "193",
                  "locator" : "121:37-121:44",
                  "name" : "Height",
                  "type" : "ExpressionRef"
               }, {
                  "localId" : "194",
                  "locator" : "121:47-121:54",
                  "name" : "Weight",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "203",
            "locator" : "140:1-141:17",
            "name" : "Birth Sex",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "203",
                  "s" : [ {
                     "value" : [ "// QUESTION: do we want to use Patient.gender as a backup? If so we'll need a ConceptMap or translation\n","define ","\"Birth Sex\"",":\n " ]
                  }, {
                     "r" : "202",
                     "s" : [ {
                        "r" : "201",
                        "s" : [ {
                           "value" : [ "Patient" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "202",
                        "s" : [ {
                           "value" : [ "birthsex" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "202",
               "locator" : "141:2-141:17",
               "type" : "SingletonFrom",
               "operand" : {
                  "type" : "Query",
                  "source" : [ {
                     "alias" : "$this",
                     "expression" : {
                        "path" : "extension",
                        "type" : "Property",
                        "source" : {
                           "localId" : "201",
                           "locator" : "141:2-141:8",
                           "name" : "Patient",
                           "type" : "ExpressionRef"
                        }
                     }
                  } ],
                  "where" : {
                     "type" : "Equal",
                     "operand" : [ {
                        "name" : "ToString",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "url",
                           "scope" : "$this",
                           "type" : "Property"
                        } ]
                     }, {
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex",
                        "type" : "Literal"
                     } ]
                  },
                  "return" : {
                     "distinct" : false,
                     "expression" : {
                        "path" : "value.value",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     }
                  }
               }
            }
         }, {
            "localId" : "210",
            "locator" : "143:1-145:17",
            "name" : "Diagnosis Codes",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "210",
                  "s" : [ {
                     "value" : [ "","define ","\"Diagnosis Codes\"",":\n  " ]
                  }, {
                     "r" : "209",
                     "s" : [ {
                        "s" : [ {
                           "r" : "205",
                           "s" : [ {
                              "r" : "204",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "UCE",".","\"All Conditions\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "208",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "207",
                           "s" : [ {
                              "r" : "206",
                              "s" : [ {
                                 "value" : [ "C" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "207",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "209",
               "locator" : "144:3-145:17",
               "type" : "Query",
               "source" : [ {
                  "localId" : "205",
                  "locator" : "144:3-144:24",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "204",
                     "locator" : "144:3-144:22",
                     "name" : "All Conditions",
                     "libraryName" : "UCE",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "208",
                  "locator" : "145:5-145:17",
                  "expression" : {
                     "localId" : "207",
                     "locator" : "145:12-145:17",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "code",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  }
               }
            }
         }, {
            "localId" : "224",
            "locator" : "147:1-149:65",
            "name" : "Diagnosis Descriptions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "224",
                  "s" : [ {
                     "value" : [ "","define ","\"Diagnosis Descriptions\"",":\n  " ]
                  }, {
                     "r" : "223",
                     "s" : [ {
                        "s" : [ {
                           "r" : "212",
                           "s" : [ {
                              "r" : "211",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Diagnosis Codes\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","ConceptItem" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "222",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "221",
                           "s" : [ {
                              "value" : [ "Combine","(" ]
                           }, {
                              "r" : "219",
                              "s" : [ {
                                 "value" : [ "(" ]
                              }, {
                                 "r" : "219",
                                 "s" : [ {
                                    "s" : [ {
                                       "r" : "215",
                                       "s" : [ {
                                          "r" : "214",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "214",
                                             "s" : [ {
                                                "r" : "213",
                                                "s" : [ {
                                                   "value" : [ "ConceptItem" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "214",
                                                "s" : [ {
                                                   "value" : [ "codes" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       }, {
                                          "value" : [ " ","C" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " " ]
                                 }, {
                                    "r" : "218",
                                    "s" : [ {
                                       "value" : [ "return " ]
                                    }, {
                                       "r" : "217",
                                       "s" : [ {
                                          "r" : "216",
                                          "s" : [ {
                                             "value" : [ "C" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "217",
                                          "s" : [ {
                                             "value" : [ "display" ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "220",
                              "s" : [ {
                                 "value" : [ "'|'" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "223",
               "locator" : "148:3-149:65",
               "type" : "Query",
               "source" : [ {
                  "localId" : "212",
                  "locator" : "148:3-148:31",
                  "alias" : "ConceptItem",
                  "expression" : {
                     "localId" : "211",
                     "locator" : "148:3-148:19",
                     "name" : "Diagnosis Codes",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "222",
                  "locator" : "149:5-149:65",
                  "expression" : {
                     "localId" : "221",
                     "locator" : "149:12-149:65",
                     "type" : "Combine",
                     "source" : {
                        "localId" : "219",
                        "locator" : "149:20-149:59",
                        "type" : "Query",
                        "source" : [ {
                           "localId" : "215",
                           "locator" : "149:21-149:41",
                           "alias" : "C",
                           "expression" : {
                              "localId" : "214",
                              "locator" : "149:21-149:39",
                              "path" : "codes",
                              "scope" : "ConceptItem",
                              "type" : "Property"
                           }
                        } ],
                        "relationship" : [ ],
                        "return" : {
                           "localId" : "218",
                           "locator" : "149:43-149:58",
                           "expression" : {
                              "localId" : "217",
                              "locator" : "149:50-149:58",
                              "path" : "display",
                              "scope" : "C",
                              "type" : "Property"
                           }
                        }
                     },
                     "separator" : {
                        "localId" : "220",
                        "locator" : "149:62-149:64",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "|",
                        "type" : "Literal"
                     }
                  }
               }
            }
         }, {
            "localId" : "229",
            "locator" : "163:1-164:38",
            "name" : "Most Recent Medication Request",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "229",
                  "s" : [ {
                     "value" : [ "","define ","\"Most Recent Medication Request\"",":\n  " ]
                  }, {
                     "r" : "228",
                     "s" : [ {
                        "r" : "227",
                        "s" : [ {
                           "value" : [ "UCE" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "228",
                        "s" : [ {
                           "value" : [ "\"Most Recent Medication Request\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "228",
               "locator" : "164:3-164:38",
               "name" : "Most Recent Medication Request",
               "libraryName" : "UCE",
               "type" : "ExpressionRef"
            }
         }, {
            "localId" : "239",
            "locator" : "151:1-153:101",
            "name" : "Medication Requested",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "239",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Requested\"",":\n  " ]
                  }, {
                     "r" : "238",
                     "s" : [ {
                        "s" : [ {
                           "r" : "226",
                           "s" : [ {
                              "r" : "225",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "UCE",".","\"All Medications\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","M" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "237",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "237",
                           "s" : [ {
                              "value" : [ "EndsWith","(" ]
                           }, {
                              "r" : "234",
                              "s" : [ {
                                 "r" : "233",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "233",
                                    "s" : [ {
                                       "r" : "231",
                                       "s" : [ {
                                          "r" : "230",
                                          "s" : [ {
                                             "value" : [ "\"Most Recent Medication Request\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "231",
                                          "s" : [ {
                                             "value" : [ "medication" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " as " ]
                                    }, {
                                       "r" : "232",
                                       "s" : [ {
                                          "value" : [ "USCore",".","Reference" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "234",
                                 "s" : [ {
                                    "value" : [ "reference" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "236",
                              "s" : [ {
                                 "r" : "235",
                                 "s" : [ {
                                    "value" : [ "M" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "236",
                                 "s" : [ {
                                    "value" : [ "id" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "238",
               "locator" : "152:3-153:101",
               "type" : "Query",
               "source" : [ {
                  "localId" : "226",
                  "locator" : "152:3-152:25",
                  "alias" : "M",
                  "expression" : {
                     "localId" : "225",
                     "locator" : "152:3-152:23",
                     "name" : "All Medications",
                     "libraryName" : "UCE",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "237",
                  "locator" : "153:5-153:101",
                  "type" : "EndsWith",
                  "operand" : [ {
                     "localId" : "234",
                     "locator" : "153:20-153:94",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "reference",
                        "type" : "Property",
                        "source" : {
                           "localId" : "233",
                           "locator" : "153:20-153:84",
                           "strict" : false,
                           "type" : "As",
                           "operand" : {
                              "localId" : "231",
                              "locator" : "153:21-153:63",
                              "name" : "ToValue",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "path" : "medication",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "230",
                                    "locator" : "153:21-153:52",
                                    "name" : "Most Recent Medication Request",
                                    "type" : "ExpressionRef"
                                 }
                              } ]
                           },
                           "asTypeSpecifier" : {
                              "localId" : "232",
                              "locator" : "153:68-153:83",
                              "name" : "{http://hl7.org/fhir}Reference",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     }
                  }, {
                     "localId" : "236",
                     "locator" : "153:97-153:100",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "id",
                        "scope" : "M",
                        "type" : "Property"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "247",
            "locator" : "155:1-157:25",
            "name" : "Medication Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "247",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Name\"",":\n  " ]
                  }, {
                     "r" : "246",
                     "s" : [ {
                        "s" : [ {
                           "r" : "241",
                           "s" : [ {
                              "r" : "240",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Medication Requested\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","M" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "245",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "244",
                           "s" : [ {
                              "r" : "243",
                              "s" : [ {
                                 "r" : "242",
                                 "s" : [ {
                                    "value" : [ "M" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "243",
                                 "s" : [ {
                                    "value" : [ "code" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "244",
                              "s" : [ {
                                 "value" : [ "display" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "246",
               "locator" : "156:3-157:25",
               "type" : "Query",
               "source" : [ {
                  "localId" : "241",
                  "locator" : "156:3-156:26",
                  "alias" : "M",
                  "expression" : {
                     "localId" : "240",
                     "locator" : "156:3-156:24",
                     "name" : "Medication Requested",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "245",
                  "locator" : "157:5-157:25",
                  "expression" : {
                     "localId" : "244",
                     "locator" : "157:12-157:25",
                     "path" : "display",
                     "type" : "Property",
                     "source" : {
                        "localId" : "243",
                        "locator" : "157:12-157:17",
                        "name" : "ToConcept",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "code",
                           "scope" : "M",
                           "type" : "Property"
                        } ]
                     }
                  }
               }
            }
         }, {
            "localId" : "254",
            "locator" : "159:1-161:17",
            "name" : "Code of Requested Drug",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "254",
                  "s" : [ {
                     "value" : [ "","define ","\"Code of Requested Drug\"",":\n  " ]
                  }, {
                     "r" : "253",
                     "s" : [ {
                        "s" : [ {
                           "r" : "249",
                           "s" : [ {
                              "r" : "248",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"Medication Requested\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","M" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "252",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "251",
                           "s" : [ {
                              "r" : "250",
                              "s" : [ {
                                 "value" : [ "M" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "251",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "253",
               "locator" : "160:3-161:17",
               "type" : "Query",
               "source" : [ {
                  "localId" : "249",
                  "locator" : "160:3-160:26",
                  "alias" : "M",
                  "expression" : {
                     "localId" : "248",
                     "locator" : "160:3-160:24",
                     "name" : "Medication Requested",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "252",
                  "locator" : "161:5-161:17",
                  "expression" : {
                     "localId" : "251",
                     "locator" : "161:12-161:17",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "code",
                        "scope" : "M",
                        "type" : "Property"
                     } ]
                  }
               }
            }
         }, {
            "localId" : "260",
            "locator" : "166:1-167:77",
            "name" : "Medication Request References",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "260",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Request References\"",":\n  " ]
                  }, {
                     "r" : "259",
                     "s" : [ {
                        "r" : "258",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "258",
                           "s" : [ {
                              "r" : "256",
                              "s" : [ {
                                 "r" : "255",
                                 "s" : [ {
                                    "value" : [ "\"Most Recent Medication Request\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "256",
                                 "s" : [ {
                                    "value" : [ "medication" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " as " ]
                           }, {
                              "r" : "257",
                              "s" : [ {
                                 "value" : [ "USCore",".","Reference" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "259",
                        "s" : [ {
                           "value" : [ "reference" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "259",
               "locator" : "167:3-167:77",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "reference",
                  "type" : "Property",
                  "source" : {
                     "localId" : "258",
                     "locator" : "167:3-167:67",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "256",
                        "locator" : "167:4-167:46",
                        "name" : "ToValue",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "medication",
                           "type" : "Property",
                           "source" : {
                              "localId" : "255",
                              "locator" : "167:4-167:35",
                              "name" : "Most Recent Medication Request",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     },
                     "asTypeSpecifier" : {
                        "localId" : "257",
                        "locator" : "167:51-167:66",
                        "name" : "{http://hl7.org/fhir}Reference",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            }
         }, {
            "localId" : "264",
            "locator" : "169:1-171:67",
            "name" : "Most Recent Medication Request dosageInstruction",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "264",
                  "s" : [ {
                     "value" : [ "","define ","\"Most Recent Medication Request dosageInstruction\"",":\n  // TODO: should this really be a singleton?\n  " ]
                  }, {
                     "r" : "263",
                     "s" : [ {
                        "value" : [ "singleton from " ]
                     }, {
                        "r" : "262",
                        "s" : [ {
                           "r" : "261",
                           "s" : [ {
                              "value" : [ "\"Most Recent Medication Request\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "262",
                           "s" : [ {
                              "value" : [ "dosageInstruction" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "263",
               "locator" : "171:3-171:67",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "262",
                  "locator" : "171:18-171:67",
                  "path" : "dosageInstruction",
                  "type" : "Property",
                  "source" : {
                     "localId" : "261",
                     "locator" : "171:18-171:49",
                     "name" : "Most Recent Medication Request",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "268",
            "locator" : "173:1-175:79",
            "name" : "Most Recent Medication Request dosageInstruction.doseAndRate",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "268",
                  "s" : [ {
                     "value" : [ "","define ","\"Most Recent Medication Request dosageInstruction.doseAndRate\"",":\n  // TODO: should this really be a singleton?\n  " ]
                  }, {
                     "r" : "267",
                     "s" : [ {
                        "value" : [ "singleton from " ]
                     }, {
                        "r" : "266",
                        "s" : [ {
                           "r" : "265",
                           "s" : [ {
                              "value" : [ "\"Most Recent Medication Request dosageInstruction\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "266",
                           "s" : [ {
                              "value" : [ "doseAndRate" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "267",
               "locator" : "175:3-175:79",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "266",
                  "locator" : "175:18-175:79",
                  "path" : "doseAndRate",
                  "type" : "Property",
                  "source" : {
                     "localId" : "265",
                     "locator" : "175:18-175:67",
                     "name" : "Most Recent Medication Request dosageInstruction",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "271",
            "locator" : "177:1-178:69",
            "name" : "Medication Dose",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "271",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Dose\"",":\n  " ]
                  }, {
                     "r" : "270",
                     "s" : [ {
                        "r" : "269",
                        "s" : [ {
                           "value" : [ "\"Most Recent Medication Request dosageInstruction.doseAndRate\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "270",
                        "s" : [ {
                           "value" : [ "dose" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "270",
               "locator" : "178:3-178:69",
               "name" : "ToValue",
               "libraryName" : "FHIRHelpers",
               "type" : "FunctionRef",
               "operand" : [ {
                  "path" : "dose",
                  "type" : "Property",
                  "source" : {
                     "localId" : "269",
                     "locator" : "178:3-178:64",
                     "name" : "Most Recent Medication Request dosageInstruction.doseAndRate",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "274",
            "locator" : "180:1-181:58",
            "name" : "Medication Route",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "274",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Route\"",":\n  " ]
                  }, {
                     "r" : "273",
                     "s" : [ {
                        "r" : "272",
                        "s" : [ {
                           "value" : [ "\"Most Recent Medication Request dosageInstruction\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "273",
                        "s" : [ {
                           "value" : [ "route" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "273",
               "locator" : "181:3-181:58",
               "name" : "ToConcept",
               "libraryName" : "FHIRHelpers",
               "type" : "FunctionRef",
               "operand" : [ {
                  "path" : "route",
                  "type" : "Property",
                  "source" : {
                     "localId" : "272",
                     "locator" : "181:3-181:52",
                     "name" : "Most Recent Medication Request dosageInstruction",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "279",
            "locator" : "183:1-184:76",
            "name" : "Medication Frequency value",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "279",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Frequency value\"",":\n  " ]
                  }, {
                     "r" : "278",
                     "s" : [ {
                        "r" : "277",
                        "s" : [ {
                           "r" : "276",
                           "s" : [ {
                              "r" : "275",
                              "s" : [ {
                                 "value" : [ "\"Most Recent Medication Request dosageInstruction\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "276",
                              "s" : [ {
                                 "value" : [ "timing" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "277",
                           "s" : [ {
                              "value" : [ "repeat" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "278",
                        "s" : [ {
                           "value" : [ "frequency" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "278",
               "locator" : "184:3-184:76",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "frequency",
                  "type" : "Property",
                  "source" : {
                     "localId" : "277",
                     "locator" : "184:3-184:66",
                     "path" : "repeat",
                     "type" : "Property",
                     "source" : {
                        "localId" : "276",
                        "locator" : "184:3-184:59",
                        "path" : "timing",
                        "type" : "Property",
                        "source" : {
                           "localId" : "275",
                           "locator" : "184:3-184:52",
                           "name" : "Most Recent Medication Request dosageInstruction",
                           "type" : "ExpressionRef"
                        }
                     }
                  }
               }
            }
         }, {
            "localId" : "296",
            "locator" : "186:1-193:5",
            "name" : "Medication Frequency Period",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "296",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Frequency Period\"",":\n  " ]
                  }, {
                     "r" : "295",
                     "s" : [ {
                        "value" : [ "if " ]
                     }, {
                        "r" : "284",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "284",
                           "s" : [ {
                              "value" : [ "IsNull","(" ]
                           }, {
                              "r" : "283",
                              "s" : [ {
                                 "r" : "282",
                                 "s" : [ {
                                    "r" : "281",
                                    "s" : [ {
                                       "r" : "280",
                                       "s" : [ {
                                          "value" : [ "\"Most Recent Medication Request dosageInstruction\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "281",
                                       "s" : [ {
                                          "value" : [ "timing" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "282",
                                    "s" : [ {
                                       "value" : [ "repeat" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "283",
                                 "s" : [ {
                                    "value" : [ "period" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "r" : "285",
                        "value" : [ " then \n    ","null","\n  else\n    " ]
                     }, {
                        "r" : "294",
                        "s" : [ {
                           "value" : [ "System",".","Quantity"," {\n      " ]
                        }, {
                           "s" : [ {
                              "value" : [ "value",": " ]
                           }, {
                              "r" : "289",
                              "s" : [ {
                                 "r" : "288",
                                 "s" : [ {
                                    "r" : "287",
                                    "s" : [ {
                                       "r" : "286",
                                       "s" : [ {
                                          "value" : [ "\"Most Recent Medication Request dosageInstruction\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "287",
                                       "s" : [ {
                                          "value" : [ "timing" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "288",
                                    "s" : [ {
                                       "value" : [ "repeat" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "289",
                                 "s" : [ {
                                    "value" : [ "period" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ",\n      " ]
                        }, {
                           "s" : [ {
                              "value" : [ "unit",": " ]
                           }, {
                              "r" : "293",
                              "s" : [ {
                                 "r" : "292",
                                 "s" : [ {
                                    "r" : "291",
                                    "s" : [ {
                                       "r" : "290",
                                       "s" : [ {
                                          "value" : [ "\"Most Recent Medication Request dosageInstruction\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "291",
                                       "s" : [ {
                                          "value" : [ "timing" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "292",
                                    "s" : [ {
                                       "value" : [ "repeat" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "293",
                                 "s" : [ {
                                    "value" : [ "periodUnit" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    }" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "295",
               "locator" : "187:3-193:5",
               "type" : "If",
               "condition" : {
                  "localId" : "284",
                  "locator" : "187:6-187:86",
                  "type" : "IsNull",
                  "operand" : {
                     "localId" : "283",
                     "locator" : "187:14-187:84",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "period",
                        "type" : "Property",
                        "source" : {
                           "localId" : "282",
                           "locator" : "187:14-187:77",
                           "path" : "repeat",
                           "type" : "Property",
                           "source" : {
                              "localId" : "281",
                              "locator" : "187:14-187:70",
                              "path" : "timing",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "280",
                                 "locator" : "187:14-187:63",
                                 "name" : "Most Recent Medication Request dosageInstruction",
                                 "type" : "ExpressionRef"
                              }
                           }
                        }
                     }
                  }
               },
               "then" : {
                  "asType" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "As",
                  "operand" : {
                     "localId" : "285",
                     "locator" : "188:5-188:8",
                     "type" : "Null"
                  }
               },
               "else" : {
                  "localId" : "294",
                  "locator" : "190:5-193:5",
                  "classType" : "{urn:hl7-org:elm-types:r1}Quantity",
                  "type" : "Instance",
                  "element" : [ {
                     "name" : "value",
                     "value" : {
                        "localId" : "289",
                        "locator" : "191:14-191:84",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "period",
                           "type" : "Property",
                           "source" : {
                              "localId" : "288",
                              "locator" : "191:14-191:77",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "287",
                                 "locator" : "191:14-191:70",
                                 "path" : "timing",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "286",
                                    "locator" : "191:14-191:63",
                                    "name" : "Most Recent Medication Request dosageInstruction",
                                    "type" : "ExpressionRef"
                                 }
                              }
                           }
                        }
                     }
                  }, {
                     "name" : "unit",
                     "value" : {
                        "localId" : "293",
                        "locator" : "192:13-192:87",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "periodUnit",
                           "type" : "Property",
                           "source" : {
                              "localId" : "292",
                              "locator" : "192:13-192:76",
                              "path" : "repeat",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "291",
                                 "locator" : "192:13-192:69",
                                 "path" : "timing",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "290",
                                    "locator" : "192:13-192:62",
                                    "name" : "Most Recent Medication Request dosageInstruction",
                                    "type" : "ExpressionRef"
                                 }
                              }
                           }
                        }
                     }
                  } ]
               }
            }
         }, {
            "localId" : "312",
            "locator" : "195:1-198:42",
            "name" : "Medication Frequency",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "312",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Frequency\"",": // '1x per 1d', '3x per 2wk', '1x per 1mo'\n  " ]
                  }, {
                     "r" : "311",
                     "s" : [ {
                        "r" : "308",
                        "s" : [ {
                           "r" : "306",
                           "s" : [ {
                              "r" : "302",
                              "s" : [ {
                                 "r" : "300",
                                 "s" : [ {
                                    "r" : "298",
                                    "s" : [ {
                                       "value" : [ "ToString","(" ]
                                    }, {
                                       "r" : "297",
                                       "s" : [ {
                                          "value" : [ "\"Medication Frequency value\"" ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "299",
                                    "s" : [ {
                                       "value" : [ "'x'" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " +\n  " ]
                              }, {
                                 "r" : "301",
                                 "s" : [ {
                                    "value" : [ "' per '" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " + " ]
                           }, {
                              "r" : "305",
                              "s" : [ {
                                 "value" : [ "ToString","(" ]
                              }, {
                                 "r" : "304",
                                 "s" : [ {
                                    "r" : "303",
                                    "s" : [ {
                                       "value" : [ "\"Medication Frequency Period\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "304",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " + \n  " ]
                        }, {
                           "r" : "307",
                           "s" : [ {
                              "value" : [ "' '" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " + " ]
                     }, {
                        "r" : "310",
                        "s" : [ {
                           "r" : "309",
                           "s" : [ {
                              "value" : [ "\"Medication Frequency Period\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "310",
                           "s" : [ {
                              "value" : [ "unit" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "311",
               "locator" : "196:3-198:42",
               "type" : "Concatenate",
               "operand" : [ {
                  "localId" : "308",
                  "locator" : "196:3-198:5",
                  "type" : "Concatenate",
                  "operand" : [ {
                     "localId" : "306",
                     "locator" : "196:3-197:57",
                     "type" : "Concatenate",
                     "operand" : [ {
                        "localId" : "302",
                        "locator" : "196:3-197:9",
                        "type" : "Concatenate",
                        "operand" : [ {
                           "localId" : "300",
                           "locator" : "196:3-196:46",
                           "type" : "Concatenate",
                           "operand" : [ {
                              "localId" : "298",
                              "locator" : "196:3-196:40",
                              "type" : "ToString",
                              "operand" : {
                                 "localId" : "297",
                                 "locator" : "196:12-196:39",
                                 "name" : "Medication Frequency value",
                                 "type" : "ExpressionRef"
                              }
                           }, {
                              "localId" : "299",
                              "locator" : "196:44-196:46",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "x",
                              "type" : "Literal"
                           } ]
                        }, {
                           "localId" : "301",
                           "locator" : "197:3-197:9",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : " per ",
                           "type" : "Literal"
                        } ]
                     }, {
                        "localId" : "305",
                        "locator" : "197:13-197:57",
                        "type" : "ToString",
                        "operand" : {
                           "localId" : "304",
                           "locator" : "197:22-197:56",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "localId" : "303",
                              "locator" : "197:22-197:50",
                              "name" : "Medication Frequency Period",
                              "type" : "ExpressionRef"
                           }
                        }
                     } ]
                  }, {
                     "localId" : "307",
                     "locator" : "198:3-198:5",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : " ",
                     "type" : "Literal"
                  } ]
               }, {
                  "localId" : "310",
                  "locator" : "198:9-198:42",
                  "path" : "unit",
                  "type" : "Property",
                  "source" : {
                     "localId" : "309",
                     "locator" : "198:9-198:37",
                     "name" : "Medication Frequency Period",
                     "type" : "ExpressionRef"
                  }
               } ]
            }
         }, {
            "localId" : "316",
            "locator" : "200:1-201:59",
            "name" : "Quantity or Number of requested Visits",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "316",
                  "s" : [ {
                     "value" : [ "","define ","\"Quantity or Number of requested Visits\"",":\n  " ]
                  }, {
                     "r" : "315",
                     "s" : [ {
                        "r" : "314",
                        "s" : [ {
                           "r" : "313",
                           "s" : [ {
                              "value" : [ "\"Most Recent Medication Request\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "314",
                           "s" : [ {
                              "value" : [ "dispenseRequest" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "315",
                        "s" : [ {
                           "value" : [ "quantity" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "315",
               "locator" : "201:3-201:59",
               "name" : "ToQuantity",
               "libraryName" : "FHIRHelpers",
               "type" : "FunctionRef",
               "operand" : [ {
                  "path" : "quantity",
                  "type" : "Property",
                  "source" : {
                     "localId" : "314",
                     "locator" : "201:3-201:50",
                     "path" : "dispenseRequest",
                     "type" : "Property",
                     "source" : {
                        "localId" : "313",
                        "locator" : "201:3-201:34",
                        "name" : "Most Recent Medication Request",
                        "type" : "ExpressionRef"
                     }
                  }
               } ]
            }
         }, {
            "localId" : "319",
            "locator" : "203:1-204:52",
            "name" : "Prior Prescription",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "319",
                  "s" : [ {
                     "value" : [ "","define ","\"Prior Prescription\"",":\n  " ]
                  }, {
                     "r" : "318",
                     "s" : [ {
                        "r" : "317",
                        "s" : [ {
                           "value" : [ "\"Most Recent Medication Request\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "318",
                        "s" : [ {
                           "value" : [ "priorPrescription" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "318",
               "locator" : "204:3-204:52",
               "path" : "priorPrescription",
               "type" : "Property",
               "source" : {
                  "localId" : "317",
                  "locator" : "204:3-204:34",
                  "name" : "Most Recent Medication Request",
                  "type" : "ExpressionRef"
               }
            }
         }, {
            "localId" : "322",
            "locator" : "206:1-207:30",
            "name" : "New therapy",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "322",
                  "s" : [ {
                     "value" : [ "","define ","\"New therapy\"",":\n  " ]
                  }, {
                     "r" : "321",
                     "s" : [ {
                        "value" : [ "IsNull","(" ]
                     }, {
                        "r" : "320",
                        "s" : [ {
                           "value" : [ "\"Prior Prescription\"" ]
                        } ]
                     }, {
                        "value" : [ ")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "321",
               "locator" : "207:3-207:30",
               "type" : "IsNull",
               "operand" : {
                  "localId" : "320",
                  "locator" : "207:10-207:29",
                  "name" : "Prior Prescription",
                  "type" : "ExpressionRef"
               }
            }
         }, {
            "localId" : "331",
            "locator" : "209:1-213:80",
            "name" : "New therapy code",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "331",
                  "s" : [ {
                     "value" : [ "","define ","\"New therapy code\"",":\n  " ]
                  }, {
                     "r" : "330",
                     "s" : [ {
                        "value" : [ "if " ]
                     }, {
                        "r" : "323",
                        "s" : [ {
                           "value" : [ "(" ]
                        }, {
                           "r" : "323",
                           "s" : [ {
                              "value" : [ "\"New therapy\"" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     }, {
                        "value" : [ " then\n    " ]
                     }, {
                        "r" : "326",
                        "s" : [ {
                           "value" : [ "System",".","Code"," { " ]
                        }, {
                           "s" : [ {
                              "value" : [ "code",": " ]
                           }, {
                              "r" : "324",
                              "s" : [ {
                                 "value" : [ "'NewMedication'" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "s" : [ {
                              "value" : [ "display",": " ]
                           }, {
                              "r" : "325",
                              "s" : [ {
                                 "value" : [ "'New Medication'" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " }" ]
                        } ]
                     }, {
                        "value" : [ "\n  else\n    " ]
                     }, {
                        "r" : "329",
                        "s" : [ {
                           "value" : [ "System",".","Code"," { " ]
                        }, {
                           "s" : [ {
                              "value" : [ "code",": " ]
                           }, {
                              "r" : "327",
                              "s" : [ {
                                 "value" : [ "'ContinuedTherapy'" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ ", " ]
                        }, {
                           "s" : [ {
                              "value" : [ "display",": " ]
                           }, {
                              "r" : "328",
                              "s" : [ {
                                 "value" : [ "'Continuation of therapy'" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " }" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "330",
               "locator" : "210:3-213:80",
               "type" : "If",
               "condition" : {
                  "localId" : "323",
                  "locator" : "210:6-210:20",
                  "name" : "New therapy",
                  "type" : "ExpressionRef"
               },
               "then" : {
                  "localId" : "326",
                  "locator" : "211:5-211:68",
                  "classType" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "Instance",
                  "element" : [ {
                     "name" : "code",
                     "value" : {
                        "localId" : "324",
                        "locator" : "211:25-211:39",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "NewMedication",
                        "type" : "Literal"
                     }
                  }, {
                     "name" : "display",
                     "value" : {
                        "localId" : "325",
                        "locator" : "211:51-211:66",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "New Medication",
                        "type" : "Literal"
                     }
                  } ]
               },
               "else" : {
                  "localId" : "329",
                  "locator" : "213:5-213:80",
                  "classType" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "Instance",
                  "element" : [ {
                     "name" : "code",
                     "value" : {
                        "localId" : "327",
                        "locator" : "213:25-213:42",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "ContinuedTherapy",
                        "type" : "Literal"
                     }
                  }, {
                     "name" : "display",
                     "value" : {
                        "localId" : "328",
                        "locator" : "213:54-213:78",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "Continuation of therapy",
                        "type" : "Literal"
                     }
                  } ]
               }
            }
         }, {
            "localId" : "350",
            "locator" : "217:1-223:8",
            "name" : "Initial date of therapy",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "350",
                  "s" : [ {
                     "value" : [ "// MISSING: needs test data to validate\n//Initial date of therapy does not return correct result if there have been more than 1 prior Prescriptions - logic needs to be adapted to that case\n","define ","\"Initial date of therapy\"",":\n  " ]
                  }, {
                     "r" : "349",
                     "s" : [ {
                        "value" : [ "if " ]
                     }, {
                        "r" : "333",
                        "s" : [ {
                           "value" : [ "not " ]
                        }, {
                           "r" : "332",
                           "s" : [ {
                              "value" : [ "\"New therapy\"" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ " then\n    " ]
                     }, {
                        "r" : "347",
                        "s" : [ {
                           "s" : [ {
                              "r" : "335",
                              "s" : [ {
                                 "r" : "334",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "UCE",".","\"All Medication Requests\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","M" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n      " ]
                        }, {
                           "r" : "343",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "343",
                              "s" : [ {
                                 "value" : [ "EndsWith","(" ]
                              }, {
                                 "r" : "340",
                                 "s" : [ {
                                    "r" : "339",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "339",
                                       "s" : [ {
                                          "r" : "337",
                                          "s" : [ {
                                             "r" : "336",
                                             "s" : [ {
                                                "value" : [ "\"Most Recent Medication Request\"" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "337",
                                             "s" : [ {
                                                "value" : [ "priorPrescription" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "338",
                                          "s" : [ {
                                             "value" : [ "USCore",".","Reference" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "340",
                                    "s" : [ {
                                       "value" : [ "reference" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "342",
                                 "s" : [ {
                                    "r" : "341",
                                    "s" : [ {
                                       "value" : [ "M" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "342",
                                    "s" : [ {
                                       "value" : [ "id" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n      " ]
                        }, {
                           "r" : "346",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "345",
                              "s" : [ {
                                 "r" : "344",
                                 "s" : [ {
                                    "value" : [ "M" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "345",
                                 "s" : [ {
                                    "value" : [ "authoredOn" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "r" : "348",
                        "value" : [ "\n  else \n    ","null" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "349",
               "locator" : "218:3-223:8",
               "type" : "If",
               "condition" : {
                  "localId" : "333",
                  "locator" : "218:6-218:22",
                  "type" : "Not",
                  "operand" : {
                     "localId" : "332",
                     "locator" : "218:10-218:22",
                     "name" : "New therapy",
                     "type" : "ExpressionRef"
                  }
               },
               "then" : {
                  "localId" : "347",
                  "locator" : "219:5-221:25",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "335",
                     "locator" : "219:5-219:35",
                     "alias" : "M",
                     "expression" : {
                        "localId" : "334",
                        "locator" : "219:5-219:33",
                        "name" : "All Medication Requests",
                        "libraryName" : "UCE",
                        "type" : "ExpressionRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "343",
                     "locator" : "220:7-220:110",
                     "type" : "EndsWith",
                     "operand" : [ {
                        "localId" : "340",
                        "locator" : "220:22-220:103",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "reference",
                           "type" : "Property",
                           "source" : {
                              "localId" : "339",
                              "locator" : "220:22-220:93",
                              "strict" : false,
                              "type" : "As",
                              "operand" : {
                                 "localId" : "337",
                                 "locator" : "220:23-220:72",
                                 "path" : "priorPrescription",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "336",
                                    "locator" : "220:23-220:54",
                                    "name" : "Most Recent Medication Request",
                                    "type" : "ExpressionRef"
                                 }
                              },
                              "asTypeSpecifier" : {
                                 "localId" : "338",
                                 "locator" : "220:77-220:92",
                                 "name" : "{http://hl7.org/fhir}Reference",
                                 "type" : "NamedTypeSpecifier"
                              }
                           }
                        }
                     }, {
                        "localId" : "342",
                        "locator" : "220:106-220:109",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "id",
                           "scope" : "M",
                           "type" : "Property"
                        }
                     } ]
                  },
                  "return" : {
                     "localId" : "346",
                     "locator" : "221:7-221:25",
                     "expression" : {
                        "localId" : "345",
                        "locator" : "221:14-221:25",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "authoredOn",
                           "scope" : "M",
                           "type" : "Property"
                        }
                     }
                  }
               },
               "else" : {
                  "type" : "As",
                  "operand" : {
                     "localId" : "348",
                     "locator" : "223:5-223:8",
                     "type" : "Null"
                  },
                  "asTypeSpecifier" : {
                     "type" : "ListTypeSpecifier",
                     "elementType" : {
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            }
         }, {
            "localId" : "354",
            "locator" : "225:1-226:65",
            "name" : "Medication Request Period",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "354",
                  "s" : [ {
                     "value" : [ "","define ","\"Medication Request Period\"",":\n  " ]
                  }, {
                     "r" : "353",
                     "s" : [ {
                        "r" : "351",
                        "s" : [ {
                           "value" : [ "CMD" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "353",
                        "s" : [ {
                           "value" : [ "\"MedicationRequestPeriod\"","(" ]
                        }, {
                           "r" : "352",
                           "s" : [ {
                              "value" : [ "\"Most Recent Medication Request\"" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "353",
               "locator" : "226:3-226:65",
               "name" : "MedicationRequestPeriod",
               "libraryName" : "CMD",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "352",
                  "locator" : "226:33-226:64",
                  "name" : "Most Recent Medication Request",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "364",
            "locator" : "228:1-231:10",
            "name" : "Expected Therapy Length",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "364",
                  "s" : [ {
                     "value" : [ "","define ","\"Expected Therapy Length\"",":\n  " ]
                  }, {
                     "r" : "363",
                     "s" : [ {
                        "value" : [ "convert" ]
                     }, {
                        "r" : "362",
                        "s" : [ {
                           "value" : [ "(\n    " ]
                        }, {
                           "r" : "362",
                           "s" : [ {
                              "r" : "355",
                              "s" : [ {
                                 "value" : [ "CMD" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "362",
                              "s" : [ {
                                 "value" : [ "Quantity","(" ]
                              }, {
                                 "r" : "360",
                                 "s" : [ {
                                    "value" : [ "days between " ]
                                 }, {
                                    "r" : "357",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "356",
                                       "s" : [ {
                                          "value" : [ "\"Medication Request Period\"" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " and " ]
                                 }, {
                                    "r" : "359",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "358",
                                       "s" : [ {
                                          "value" : [ "\"Medication Request Period\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "361",
                                 "s" : [ {
                                    "value" : [ "'d'" ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     }, {
                        "value" : [ " to ","'d'" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "363",
               "locator" : "229:3-231:10",
               "type" : "ConvertQuantity",
               "operand" : [ {
                  "localId" : "362",
                  "locator" : "229:10-231:3",
                  "name" : "Quantity",
                  "libraryName" : "CMD",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "type" : "ToDecimal",
                     "operand" : {
                        "localId" : "360",
                        "locator" : "230:18-230:105",
                        "precision" : "Day",
                        "type" : "DurationBetween",
                        "operand" : [ {
                           "localId" : "357",
                           "locator" : "230:31-230:66",
                           "type" : "Start",
                           "operand" : {
                              "localId" : "356",
                              "locator" : "230:40-230:66",
                              "name" : "Medication Request Period",
                              "type" : "ExpressionRef"
                           }
                        }, {
                           "localId" : "359",
                           "locator" : "230:72-230:105",
                           "type" : "End",
                           "operand" : {
                              "localId" : "358",
                              "locator" : "230:79-230:105",
                              "name" : "Medication Request Period",
                              "type" : "ExpressionRef"
                           }
                        } ]
                     }
                  }, {
                     "localId" : "361",
                     "locator" : "230:108-230:110",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "d",
                     "type" : "Literal"
                  } ]
               }, {
                  "locator" : "231:8-231:10",
                  "valueType" : "{urn:hl7-org:elm-types:r1}String",
                  "value" : "d",
                  "type" : "Literal"
               } ]
            }
         }, {
            "localId" : "367",
            "locator" : "233:1-234:38",
            "name" : "Anticipated/actual date of service",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "367",
                  "s" : [ {
                     "value" : [ "","define ","\"Anticipated/actual date of service\"",":\n  " ]
                  }, {
                     "r" : "366",
                     "s" : [ {
                        "value" : [ "start of " ]
                     }, {
                        "r" : "365",
                        "s" : [ {
                           "value" : [ "\"Medication Request Period\"" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "366",
               "locator" : "234:3-234:38",
               "type" : "Start",
               "operand" : {
                  "localId" : "365",
                  "locator" : "234:12-234:38",
                  "name" : "Medication Request Period",
                  "type" : "ExpressionRef"
               }
            }
         } ]
      }
   }
}" + } ] +} \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCore-ModelInfo.json b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCore-ModelInfo.json new file mode 100644 index 000000000..ec4a196ef --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCore-ModelInfo.json @@ -0,0 +1,53 @@ +{ + "resourceType": "Library", + "id": "USCore-ModelInfo", + "meta": { + "profile": [ "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-shareablelibrary", "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-publishablelibrary" ] + }, + "extension": [ { + "url": "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-knowledgeCapability", + "valueCode": "shareable" + }, { + "url": "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-knowledgeCapability", + "valueCode": "publishable" + }, { + "url": "http://hl7.org/fhir/uv/cpg/StructureDefinition/cpg-knowledgeRepresentationLevel", + "valueCode": "structured" + }, { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } ], + "version": "3.1.1", + "name": "USCore", + "title": "USCore Model Definition", + "status": "active", + "experimental": false, + "type": { + "coding": [ { + "system": "http://terminology.hl7.org/CodeSystem/library-type", + "code": "model-definition" + } ] + }, + "date": "2021-03-12", + "description": "Model definition for US Core STU3 (v3.1.0)", + "approvalDate": "2021-03-12", + "lastReviewDate": "2021-03-12", + "topic": [ { + "text": "FHIR" + }, { + "text": "CQL" + }, { + "text": "US" + } ], + "relatedArtifact": [ { + "type": "depends-on", + "resource": "http://fhir.org/guides/cqf/common/Library/FHIR-ModelInfo|4.0.1" + } ], + "content": [ { + "contentType": "application/xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<modelInfo xmlns="urn:hl7-org:elm-modelinfo:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="USCore" version="3.1.1" url="http://hl7.org/fhir/us/core" targetUrl="http://hl7.org/fhir" targetQualifier="uscore" patientClassName="PatientProfile" patientBirthDatePropertyName="birthDate">
   <requiredModelInfo name="System" version="1.0.0"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Address" identifier="http://hl7.org/fhir/StructureDefinition/Address" label="Address" retrievable="false">
      <element name="use" elementType="USCore.AddressUse" target="%value.value"/>
      <element name="type" elementType="USCore.AddressType" target="%value.value"/>
      <element name="text" elementType="System.String" target="%value.value"/>
      <element name="line" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="city" elementType="System.String" target="%value.value"/>
      <element name="district" elementType="System.String" target="%value.value"/>
      <element name="state" elementType="System.String" target="%value.value"/>
      <element name="postalCode" elementType="System.String" target="%value.value"/>
      <element name="country" elementType="System.String" target="%value.value"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="AddressType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="AddressUse" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="AdministrativeGender" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="AllergyIntolerance" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" label="US  Core AllergyIntolerance Profile" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="clinicalStatus" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="verificationStatus" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="type" elementType="USCore.AllergyIntoleranceType" target="%value.value"/>
      <element name="category" target="%value.value">
         <elementTypeSpecifier elementType="USCore.AllergyIntoleranceCategory" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="criticality" elementType="USCore.AllergyIntoleranceCriticality" target="%value.value"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="patient" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="onset" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="recordedDate" elementType="System.DateTime" target="%value.value"/>
      <element name="recorder" elementType="USCore.Reference"/>
      <element name="asserter" elementType="USCore.Reference"/>
      <element name="lastOccurrence" elementType="System.DateTime" target="%value.value"/>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reaction">
         <elementTypeSpecifier elementType="USCore.AllergyIntolerance.Reaction" xsi:type="ListTypeSpecifier"/>
      </element>
      <contextRelationship context="Patient" relatedKeyElement="patient"/>
      <contextRelationship context="Patient" relatedKeyElement="recorder"/>
      <contextRelationship context="Patient" relatedKeyElement="asserter"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="AllergyIntolerance.Reaction" retrievable="false">
      <element name="substance" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="manifestation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="description" elementType="System.String" target="%value.value"/>
      <element name="onset" elementType="System.DateTime" target="%value.value"/>
      <element name="severity" elementType="USCore.AllergyIntoleranceSeverity" target="%value.value"/>
      <element name="exposureRoute" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="AllergyIntoleranceCategory" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="AllergyIntoleranceCriticality" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="AllergyIntoleranceSeverity" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="AllergyIntoleranceType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Annotation" identifier="http://hl7.org/fhir/StructureDefinition/Annotation" label="Annotation" retrievable="false">
      <element name="author" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="time" elementType="System.DateTime" target="%value.value"/>
      <element name="text" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Attachment" identifier="http://hl7.org/fhir/StructureDefinition/Attachment" label="Attachment" retrievable="false">
      <element name="contentType" elementType="USCore.MimeType" target="%value.value"/>
      <element name="language" elementType="System.String" target="%value.value"/>
      <element name="data" elementType="System.String" target="%value.value"/>
      <element name="url" elementType="System.String" target="%value.value"/>
      <element name="size" elementType="System.Integer" target="%value.value"/>
      <element name="hash" elementType="System.String" target="%value.value"/>
      <element name="title" elementType="System.String" target="%value.value"/>
      <element name="creation" elementType="System.DateTime" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="BackboneElement" identifier="http://hl7.org/fhir/StructureDefinition/BackboneElement" label="BackboneElement" retrievable="false">
      <element name="modifierExtension">
         <elementTypeSpecifier elementType="USCore.Extension" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="BirthSexExtension" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex" label="US Core Birth Sex Extension" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="BodyLengthUnits" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="BodyTempUnits" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="BodyWeightUnits" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="CarePlan.Activity" retrievable="false">
      <element name="outcomeCodeableConcept" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="outcomeReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="progress">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reference" elementType="USCore.Reference"/>
      <element name="detail" elementType="USCore.CarePlan.Activity.Detail"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="CarePlan.Activity.Detail" retrievable="false">
      <element name="kind" elementType="USCore.CarePlanActivityKind" target="%value.value"/>
      <element name="instantiatesCanonical" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="instantiatesUri" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="reasonCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="goal">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.CarePlanActivityStatus" target="%value.value"/>
      <element name="statusReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="doNotPerform" elementType="System.Boolean" target="%value.value"/>
      <element name="scheduled" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="USCore" name="Timing" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="location" elementType="USCore.Reference"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="product" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="dailyAmount" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="quantity" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="description" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="CarePlanActivityKind" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="CarePlanActivityStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="CarePlanProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-careplan" label="US Core CarePlan Profile" target="CarePlan" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="instantiatesCanonical" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="instantiatesUri" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="replaces">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="intent" elementType="System.String" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="AssessPlan" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="title" elementType="System.String" target="%value.value"/>
      <element name="description" elementType="System.String" target="%value.value"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="created" elementType="System.DateTime" target="%value.value"/>
      <element name="author" elementType="USCore.Reference"/>
      <element name="contributor">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="careTeam">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="addresses">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="supportingInfo">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="goal">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="activity">
         <elementTypeSpecifier elementType="USCore.CarePlan.Activity" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="CareTeam" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-careteam" label="US Core CareTeam Profile" retrievable="true" primaryCodePath="category">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="participant">
         <elementTypeSpecifier elementType="USCore.CareTeam.Participant" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="managingOrganization">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <contextRelationship context="Patient" relatedKeyElement="patient"/>
      <contextRelationship context="Patient" relatedKeyElement="member"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="CareTeam.Participant" retrievable="false">
      <element name="role" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="member" elementType="USCore.Reference"/>
      <element name="onBehalfOf" elementType="USCore.Reference"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="Condition" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" label="US Core Condition Profile" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="clinicalStatus" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="verificationStatus" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="severity" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="bodySite" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="onset" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="abatement" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="recordedDate" elementType="System.DateTime" target="%value.value"/>
      <element name="recorder" elementType="USCore.Reference"/>
      <element name="asserter" elementType="USCore.Reference"/>
      <element name="stage">
         <elementTypeSpecifier elementType="USCore.Condition.Stage" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="evidence">
         <elementTypeSpecifier elementType="USCore.Condition.Evidence" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <contextRelationship context="Patient" relatedKeyElement="patient"/>
      <contextRelationship context="Patient" relatedKeyElement="asserter"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Condition.Evidence" retrievable="false">
      <element name="code" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="detail">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Condition.Stage" retrievable="false">
      <element name="summary" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="assessment">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="ContactDetail" identifier="http://hl7.org/fhir/StructureDefinition/ContactDetail" label="ContactDetail" retrievable="false">
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="ContactPoint" identifier="http://hl7.org/fhir/StructureDefinition/ContactPoint" label="ContactPoint" retrievable="false">
      <element name="system" elementType="USCore.ContactPointSystem" target="%value.value"/>
      <element name="value" elementType="System.String" target="%value.value"/>
      <element name="use" elementType="USCore.ContactPointUse" target="%value.value"/>
      <element name="rank" elementType="System.Integer" target="%value.value"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="ContactPointSystem" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="ContactPointUse" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Contributor" identifier="http://hl7.org/fhir/StructureDefinition/Contributor" label="Contributor" retrievable="false">
      <element name="type" elementType="USCore.ContributorType" target="%value.value"/>
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="contact">
         <elementTypeSpecifier elementType="USCore.ContactDetail" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="ContributorType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="DataRequirement" identifier="http://hl7.org/fhir/StructureDefinition/DataRequirement" label="DataRequirement" retrievable="false">
      <element name="type" elementType="USCore.FHIRAllTypes" target="%value.value"/>
      <element name="profile" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="subject" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="mustSupport" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="codeFilter">
         <elementTypeSpecifier elementType="USCore.DataRequirement.CodeFilter" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="dateFilter">
         <elementTypeSpecifier elementType="USCore.DataRequirement.DateFilter" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="limit" elementType="System.Integer" target="%value.value"/>
      <element name="sort">
         <elementTypeSpecifier elementType="USCore.DataRequirement.Sort" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="DataRequirement.CodeFilter" retrievable="false">
      <element name="path" elementType="System.String" target="%value.value"/>
      <element name="searchParam" elementType="System.String" target="%value.value"/>
      <element name="valueSet" elementType="System.String" target="%value.value"/>
      <element name="code" target="FHIRHelpers.ToCode(%value)">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="DataRequirement.DateFilter" retrievable="false">
      <element name="path" elementType="System.String" target="%value.value"/>
      <element name="searchParam" elementType="System.String" target="%value.value"/>
      <element name="value" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="DataRequirement.Sort" retrievable="false">
      <element name="path" elementType="System.String" target="%value.value"/>
      <element name="direction" elementType="USCore.SortDirection" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="DayOfWeek" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="DaysOfWeek" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Device.DeviceName" retrievable="false">
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="type" elementType="USCore.DeviceNameType" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Device.Property" retrievable="false">
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="valueQuantity" target="FHIRHelpers.ToQuantity(%value)">
         <elementTypeSpecifier elementType="System.Quantity" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="valueCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Device.Specialization" retrievable="false">
      <element name="systemType" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="version" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Device.UdiCarrier" retrievable="false">
      <element name="deviceIdentifier" elementType="System.String" target="%value.value"/>
      <element name="issuer" elementType="System.String" target="%value.value"/>
      <element name="jurisdiction" elementType="System.String" target="%value.value"/>
      <element name="carrierAIDC" elementType="System.String" target="%value.value"/>
      <element name="carrierHRF" elementType="System.String" target="%value.value"/>
      <element name="entryType" elementType="USCore.UDIEntryType" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Device.Version" retrievable="false">
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="component" elementType="USCore.Identifier"/>
      <element name="value" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="DeviceNameType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="DiagnosticReport.Media" retrievable="false">
      <element name="comment" elementType="System.String" target="%value.value"/>
      <element name="link" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="DiagnosticReportProfileLaboratoryReporting" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab" label="US Core DiagnosticReport Profile for Laboratory Results Reporting" target="DiagnosticReport" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="LaboratorySlice" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="resultsInterpreter">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="specimen">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="result">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="imagingStudy">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="media">
         <elementTypeSpecifier elementType="USCore.DiagnosticReport.Media" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="conclusion" elementType="System.String" target="%value.value"/>
      <element name="conclusionCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="presentedForm">
         <elementTypeSpecifier elementType="USCore.Attachment" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="DiagnosticReportProfileNoteExchange" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note" label="US Core DiagnosticReport Profile for Report and Note exchange" target="DiagnosticReport" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="resultsInterpreter">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="specimen">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="result">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="imagingStudy">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="media">
         <elementTypeSpecifier elementType="USCore.DiagnosticReport.Media" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="conclusion" elementType="System.String" target="%value.value"/>
      <element name="conclusionCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="presentedForm">
         <elementTypeSpecifier elementType="USCore.Attachment" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="DocumentReference.Content" retrievable="false">
      <element name="attachment" elementType="USCore.Attachment"/>
      <element name="format" elementType="System.Code" target="FHIRHelpers.ToCode(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="DocumentReference.Context" retrievable="false">
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="event" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="facilityType" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="practiceSetting" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="sourcePatientInfo" elementType="USCore.Reference"/>
      <element name="related">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="DocumentReference.RelatesTo" retrievable="false">
      <element name="code" elementType="USCore.DocumentRelationshipType" target="%value.value"/>
      <element name="target" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="DocumentReferenceProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-documentreference" label="US Core DocumentReference Profile" target="DocumentReference" retrievable="true">
      <element name="masterIdentifier" elementType="USCore.Identifier"/>
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="docStatus" elementType="USCore.ReferredDocumentStatus" target="%value.value"/>
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="date" elementType="System.DateTime" target="%value.value"/>
      <element name="author">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="authenticator" elementType="USCore.Reference"/>
      <element name="custodian" elementType="USCore.Reference"/>
      <element name="relatesTo">
         <elementTypeSpecifier elementType="USCore.DocumentReference.RelatesTo" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="description" elementType="System.String" target="%value.value"/>
      <element name="securityLabel" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="content">
         <elementTypeSpecifier elementType="USCore.DocumentReference.Content" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="context" elementType="USCore.DocumentReference.Context"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="DocumentRelationshipType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Resource" namespace="USCore" name="DomainResource" identifier="http://hl7.org/fhir/StructureDefinition/DomainResource" label="DomainResource" retrievable="true">
      <element name="text" elementType="USCore.Narrative"/>
      <element name="contained">
         <elementTypeSpecifier elementType="USCore.Resource" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="extension">
         <elementTypeSpecifier elementType="USCore.Extension" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="modifierExtension">
         <elementTypeSpecifier elementType="USCore.Extension" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Dosage" identifier="http://hl7.org/fhir/StructureDefinition/Dosage" label="Dosage" retrievable="false">
      <element name="sequence" elementType="System.Integer" target="%value.value"/>
      <element name="text" elementType="System.String" target="%value.value"/>
      <element name="additionalInstruction" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="patientInstruction" elementType="System.String" target="%value.value"/>
      <element name="timing" elementType="USCore.Timing"/>
      <element name="asNeeded" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="site" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="route" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="doseAndRate">
         <elementTypeSpecifier elementType="USCore.Dosage.DoseAndRate" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="maxDosePerPeriod" elementType="System.Ratio" target="FHIRHelpers.ToRatio(%value)"/>
      <element name="maxDosePerAdministration" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="maxDosePerLifetime" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Dosage.DoseAndRate" retrievable="false">
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="dose" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="rate" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Ratio" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.Any" namespace="USCore" name="Element" identifier="http://hl7.org/fhir/StructureDefinition/Element" label="Element" retrievable="false">
      <element name="id" elementType="System.String" target="%value.value"/>
      <element name="extension">
         <elementTypeSpecifier elementType="USCore.Extension" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Encounter.ClassHistory" retrievable="false">
      <element name="class" elementType="System.Code" target="FHIRHelpers.ToCode(%value)"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Encounter.Diagnosis" retrievable="false">
      <element name="condition" elementType="USCore.Reference"/>
      <element name="use" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="rank" elementType="System.Integer" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Encounter.Hospitalization" retrievable="false">
      <element name="preAdmissionIdentifier" elementType="USCore.Identifier"/>
      <element name="origin" elementType="USCore.Reference"/>
      <element name="admitSource" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="reAdmission" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="dietPreference" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="specialCourtesy" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="specialArrangement" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="destination" elementType="USCore.Reference"/>
      <element name="dischargeDisposition" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Encounter.Location" retrievable="false">
      <element name="location" elementType="USCore.Reference"/>
      <element name="status" elementType="USCore.EncounterLocationStatus" target="%value.value"/>
      <element name="physicalType" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Encounter.Participant" retrievable="false">
      <element name="type" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="individual" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Encounter.StatusHistory" retrievable="false">
      <element name="status" elementType="USCore.EncounterStatus" target="%value.value"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="EncounterLocationStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="EncounterProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" label="US Core Encounter Profile" target="Encounter" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.EncounterStatus" target="%value.value"/>
      <element name="statusHistory">
         <elementTypeSpecifier elementType="USCore.Encounter.StatusHistory" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="class" elementType="System.Code" target="FHIRHelpers.ToCode(%value)"/>
      <element name="classHistory">
         <elementTypeSpecifier elementType="USCore.Encounter.ClassHistory" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="type" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="serviceType" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="priority" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="episodeOfCare">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="participant">
         <elementTypeSpecifier elementType="USCore.Encounter.Participant" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="appointment">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="length" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="reasonCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="diagnosis">
         <elementTypeSpecifier elementType="USCore.Encounter.Diagnosis" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="account">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hospitalization" elementType="USCore.Encounter.Hospitalization"/>
      <element name="location">
         <elementTypeSpecifier elementType="USCore.Encounter.Location" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="serviceProvider" elementType="USCore.Reference"/>
      <element name="partOf" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="EncounterStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Extension" namespace="USCore" name="EthnicityExtension" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity" label="US Core Ethnicity Extension" retrievable="false">
      <element name="ombCategory" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.extension[url='ombCategory'].value)"/>
      <element name="detailed" target="FHIRHelpers.ToCode(%parent.extension[url='detailed'].value)">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="text" elementType="System.String" target="%parent.extension[url='text'].value.value"/>
      <element name="url" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="EventTiming" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Expression" identifier="http://hl7.org/fhir/StructureDefinition/Expression" label="Expression" retrievable="false">
      <element name="description" elementType="System.String" target="%value.value"/>
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="language" elementType="System.String" target="%value.value"/>
      <element name="expression" elementType="System.String" target="%value.value"/>
      <element name="reference" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Extension" identifier="http://hl7.org/fhir/StructureDefinition/Extension" label="Extension" retrievable="false">
      <element name="url" elementType="System.String" target="%value.value"/>
      <element name="value" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Date" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Decimal" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Time" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Address" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Annotation" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Attachment" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Code" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="ContactPoint" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="HumanName" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Identifier" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Decimal" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Ratio" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="SampledData" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Signature" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Timing" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="ContactDetail" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Contributor" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="DataRequirement" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Expression" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="ParameterDefinition" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="RelatedArtifact" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="TriggerDefinition" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="UsageContext" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Dosage" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Meta" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="FHIRAllTypes" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="FHIRDeviceStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Goal.Target" retrievable="false">
      <element name="measure" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="detail" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Ratio" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="due" elementType="System.Date" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="GoalProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-goal" label="US Core Goal Profile" target="Goal" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="lifecycleStatus" elementType="System.String" target="%value.value"/>
      <element name="achievementStatus" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="priority" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="description" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="start" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Date" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="target">
         <elementTypeSpecifier elementType="USCore.Goal.Target" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="statusDate" elementType="System.Date" target="%value.value"/>
      <element name="statusReason" elementType="System.String" target="%value.value"/>
      <element name="expressedBy" elementType="USCore.Reference"/>
      <element name="addresses">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="outcomeCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="outcomeReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="HumanName" identifier="http://hl7.org/fhir/StructureDefinition/HumanName" label="HumanName" retrievable="false">
      <element name="use" elementType="USCore.NameUse" target="%value.value"/>
      <element name="text" elementType="System.String" target="%value.value"/>
      <element name="family" elementType="System.String" target="%value.value"/>
      <element name="given" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="prefix" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="suffix" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Identifier" identifier="http://hl7.org/fhir/StructureDefinition/Identifier" label="Identifier" retrievable="false">
      <element name="use" elementType="USCore.IdentifierUse" target="%value.value"/>
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="system" elementType="System.String" target="%value.value"/>
      <element name="value" elementType="System.String" target="%value.value"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="assigner" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="IdentifierUse" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Immunization.Education" retrievable="false">
      <element name="documentType" elementType="System.String" target="%value.value"/>
      <element name="reference" elementType="System.String" target="%value.value"/>
      <element name="publicationDate" elementType="System.DateTime" target="%value.value"/>
      <element name="presentationDate" elementType="System.DateTime" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Immunization.Performer" retrievable="false">
      <element name="function" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="actor" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Immunization.ProtocolApplied" retrievable="false">
      <element name="series" elementType="System.String" target="%value.value"/>
      <element name="authority" elementType="USCore.Reference"/>
      <element name="targetDisease" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="doseNumber" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="seriesDoses" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Immunization.Reaction" retrievable="false">
      <element name="date" elementType="System.DateTime" target="%value.value"/>
      <element name="detail" elementType="USCore.Reference"/>
      <element name="reported" elementType="System.Boolean" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="ImmunizationProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization" label="US Core Immunization Profile" target="Immunization" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="statusReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="vaccineCode" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="patient" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="occurrence" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="recorded" elementType="System.DateTime" target="%value.value"/>
      <element name="primarySource" elementType="System.Boolean" target="%value.value"/>
      <element name="reportOrigin" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="location" elementType="USCore.Reference"/>
      <element name="manufacturer" elementType="USCore.Reference"/>
      <element name="lotNumber" elementType="System.String" target="%value.value"/>
      <element name="expirationDate" elementType="System.Date" target="%value.value"/>
      <element name="site" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="route" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="doseQuantity" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Immunization.Performer" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="isSubpotent" elementType="System.Boolean" target="%value.value"/>
      <element name="subpotentReason" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="education">
         <elementTypeSpecifier elementType="USCore.Immunization.Education" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="programEligibility" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="fundingSource" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="reaction">
         <elementTypeSpecifier elementType="USCore.Immunization.Reaction" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="protocolApplied">
         <elementTypeSpecifier elementType="USCore.Immunization.ProtocolApplied" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="ImplantableDeviceProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device" label="US Core Implantable Device Profile" target="Device" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="definition" elementType="USCore.Reference"/>
      <element name="udiCarrier" elementType="USCore.Device.UdiCarrier"/>
      <element name="status" elementType="USCore.FHIRDeviceStatus" target="%value.value"/>
      <element name="statusReason" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="distinctIdentifier" elementType="System.String" target="%value.value"/>
      <element name="manufacturer" elementType="System.String" target="%value.value"/>
      <element name="manufactureDate" elementType="System.DateTime" target="%value.value"/>
      <element name="expirationDate" elementType="System.DateTime" target="%value.value"/>
      <element name="lotNumber" elementType="System.String" target="%value.value"/>
      <element name="serialNumber" elementType="System.String" target="%value.value"/>
      <element name="deviceName">
         <elementTypeSpecifier elementType="USCore.Device.DeviceName" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="modelNumber" elementType="System.String" target="%value.value"/>
      <element name="partNumber" elementType="System.String" target="%value.value"/>
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specialization">
         <elementTypeSpecifier elementType="USCore.Device.Specialization" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="version">
         <elementTypeSpecifier elementType="USCore.Device.Version" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="property">
         <elementTypeSpecifier elementType="USCore.Device.Property" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="patient" elementType="USCore.Reference"/>
      <element name="owner" elementType="USCore.Reference"/>
      <element name="contact">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="location" elementType="USCore.Reference"/>
      <element name="url" elementType="System.String" target="%value.value"/>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="safety" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="parent" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="LaboratoryResultObservationProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab" label="US Core Laboratory Result Observation Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="Laboratory" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Ratio" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="SampledData" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Time" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="LinkType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="Location" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-location" label="US Core Location Profile" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.LocationStatus" target="%value.value"/>
      <element name="operationalStatus" elementType="System.Code" target="FHIRHelpers.ToCode(%value)"/>
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="alias" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="description" elementType="System.String" target="%value.value"/>
      <element name="mode" elementType="USCore.LocationMode" target="%value.value"/>
      <element name="type" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="address" elementType="USCore.Address"/>
      <element name="physicalType" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="position" elementType="USCore.Location.Position"/>
      <element name="managingOrganization" elementType="USCore.Reference"/>
      <element name="partOf" elementType="USCore.Reference"/>
      <element name="hoursOfOperation">
         <elementTypeSpecifier elementType="USCore.Location.HoursOfOperation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="availabilityExceptions" elementType="System.String" target="%value.value"/>
      <element name="endpoint">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Location.HoursOfOperation" retrievable="false">
      <element name="daysOfWeek" target="%value.value">
         <elementTypeSpecifier elementType="USCore.DaysOfWeek" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="allDay" elementType="System.Boolean" target="%value.value"/>
      <element name="openingTime" elementType="System.Time" target="%value.value"/>
      <element name="closingTime" elementType="System.Time" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Location.Position" retrievable="false">
      <element name="longitude" elementType="System.Decimal" target="%value.value"/>
      <element name="latitude" elementType="System.Decimal" target="%value.value"/>
      <element name="altitude" elementType="System.Decimal" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="LocationMode" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="LocationStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Medication.Batch" retrievable="false">
      <element name="lotNumber" elementType="System.String" target="%value.value"/>
      <element name="expirationDate" elementType="System.DateTime" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Medication.Ingredient" retrievable="false">
      <element name="item" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="isActive" elementType="System.Boolean" target="%value.value"/>
      <element name="strength" elementType="System.Ratio" target="FHIRHelpers.ToRatio(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="MedicationProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" label="US Core Medication Profile" target="Medication" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="status" elementType="USCore.MedicationStatus" target="%value.value"/>
      <element name="manufacturer" elementType="USCore.Reference"/>
      <element name="form" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="amount" elementType="System.Ratio" target="FHIRHelpers.ToRatio(%value)"/>
      <element name="ingredient">
         <elementTypeSpecifier elementType="USCore.Medication.Ingredient" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="batch" elementType="USCore.Medication.Batch"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="MedicationRequest.DispenseRequest" retrievable="false">
      <element name="initialFill" elementType="USCore.MedicationRequest.DispenseRequest.InitialFill"/>
      <element name="dispenseInterval" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="validityPeriod" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="numberOfRepeatsAllowed" elementType="System.Integer" target="%value.value"/>
      <element name="quantity" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="expectedSupplyDuration" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="performer" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="MedicationRequest.DispenseRequest.InitialFill" retrievable="false">
      <element name="quantity" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="duration" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="MedicationRequest.Substitution" retrievable="false">
      <element name="allowed" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="reason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="MedicationRequestPriority" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="MedicationRequestProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest" label="US Core MedicationRequest Profile" target="MedicationRequest" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="statusReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="intent" elementType="System.String" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="priority" elementType="USCore.MedicationRequestPriority" target="%value.value"/>
      <element name="doNotPerform" elementType="System.Boolean" target="%value.value"/>
      <element name="reported" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="medication" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="supportingInformation">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="authoredOn" elementType="System.DateTime" target="%value.value"/>
      <element name="requester" elementType="USCore.Reference"/>
      <element name="performer" elementType="USCore.Reference"/>
      <element name="performerType" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="recorder" elementType="USCore.Reference"/>
      <element name="reasonCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="instantiatesCanonical" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="instantiatesUri" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="groupIdentifier" elementType="USCore.Identifier"/>
      <element name="courseOfTherapyType" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="insurance">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="dosageInstruction">
         <elementTypeSpecifier elementType="USCore.Dosage" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="dispenseRequest" elementType="USCore.MedicationRequest.DispenseRequest"/>
      <element name="substitution" elementType="USCore.MedicationRequest.Substitution"/>
      <element name="priorPrescription" elementType="USCore.Reference"/>
      <element name="detectedIssue">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="eventHistory">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="MedicationStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Meta" identifier="http://hl7.org/fhir/StructureDefinition/Meta" label="Meta" retrievable="false">
      <element name="versionId" elementType="System.String" target="%value.value"/>
      <element name="lastUpdated" elementType="System.DateTime" target="%value.value"/>
      <element name="source" elementType="System.String" target="%value.value"/>
      <element name="profile" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="security" target="FHIRHelpers.ToCode(%value)">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="tag" target="FHIRHelpers.ToCode(%value)">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="MimeType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="NameUse" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Narrative" identifier="http://hl7.org/fhir/StructureDefinition/Narrative" label="Narrative" retrievable="false">
      <element name="status" elementType="USCore.NarrativeStatus" target="%value.value"/>
      <element name="div" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="NarrativeStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Observation.Component" retrievable="false">
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="value" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="String" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="Ratio" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="SampledData" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Time" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="referenceRange">
         <elementTypeSpecifier xsi:type="ListTypeSpecifier">
            <elementTypeSpecifier namespace="USCore" name="Observation.ReferenceRange" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Observation.Component" namespace="USCore" name="Observation.Component.Concentration" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Observation.Component" namespace="USCore" name="Observation.Component.DiastolicBP" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Observation.Component" namespace="USCore" name="Observation.Component.FlowRate" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Observation.Component" namespace="USCore" name="Observation.Component.SystolicBP" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Observation.ReferenceRange" retrievable="false">
      <element name="low" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="high" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="appliesTo" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="age" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="text" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Organization.Contact" retrievable="false">
      <element name="purpose" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="name" elementType="USCore.HumanName"/>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="address" elementType="USCore.Address"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="OrganizationProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" label="US Core Organization Profile" target="Organization" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="NPI" elementType="USCore.Identifier"/>
      <element name="CLIA" elementType="USCore.Identifier"/>
      <element name="active" elementType="System.Boolean" target="%value.value"/>
      <element name="type" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="alias" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="address">
         <elementTypeSpecifier elementType="USCore.Address" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf" elementType="USCore.Reference"/>
      <element name="contact">
         <elementTypeSpecifier elementType="USCore.Organization.Contact" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="endpoint">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="ParameterDefinition" identifier="http://hl7.org/fhir/StructureDefinition/ParameterDefinition" label="ParameterDefinition" retrievable="false">
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="use" elementType="USCore.ParameterUse" target="%value.value"/>
      <element name="min" elementType="System.Integer" target="%value.value"/>
      <element name="max" elementType="System.String" target="%value.value"/>
      <element name="documentation" elementType="System.String" target="%value.value"/>
      <element name="type" elementType="USCore.FHIRAllTypes" target="%value.value"/>
      <element name="profile" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="ParameterUse" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Patient.Communication" retrievable="false">
      <element name="language" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="preferred" elementType="System.Boolean" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Patient.Contact" retrievable="false">
      <element name="relationship" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="name" elementType="USCore.HumanName"/>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="address" elementType="USCore.Address"/>
      <element name="gender" elementType="USCore.AdministrativeGender" target="%value.value"/>
      <element name="organization" elementType="USCore.Reference"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Patient.Link" retrievable="false">
      <element name="other" elementType="USCore.Reference"/>
      <element name="type" elementType="USCore.LinkType" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="PatientProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" label="US Core Patient Profile" target="Patient" retrievable="true">
      <element name="race" elementType="USCore.RaceExtension" target="%parent.extension[url='http://hl7.org/fhir/us/core/StructureDefinition/us-core-race']"/>
      <element name="ethnicity" elementType="USCore.EthnicityExtension" target="%parent.extension[url='http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity']"/>
      <element name="birthsex" elementType="USCore.BirthSexExtension" target="%parent.extension[url='http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex'].value.value"/>
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="active" elementType="System.Boolean" target="%value.value"/>
      <element name="name">
         <elementTypeSpecifier elementType="USCore.HumanName" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="gender" elementType="System.String" target="%value.value"/>
      <element name="birthDate" elementType="System.Date" target="%value.value"/>
      <element name="deceased" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="address">
         <elementTypeSpecifier elementType="USCore.Address" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="maritalStatus" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="multipleBirth" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Boolean" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Integer" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="photo">
         <elementTypeSpecifier elementType="USCore.Attachment" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="contact">
         <elementTypeSpecifier elementType="USCore.Patient.Contact" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="communication">
         <elementTypeSpecifier elementType="USCore.Patient.Communication" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="generalPractitioner">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="managingOrganization" elementType="USCore.Reference"/>
      <element name="link">
         <elementTypeSpecifier elementType="USCore.Patient.Link" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="PediatricBMIforAgeObservationProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age" label="US Core Pediatric BMI for Age Observation Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="PediatricWeightForHeightObservationProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height" label="US Core Pediatric Weight for Height Observation Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Practitioner.Qualification" retrievable="false">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="issuer" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="PractitionerProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" label="US Core Practitioner Profile" target="Practitioner" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="NPI" elementType="USCore.Identifier"/>
      <element name="active" elementType="System.Boolean" target="%value.value"/>
      <element name="name">
         <elementTypeSpecifier elementType="USCore.HumanName" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="address">
         <elementTypeSpecifier elementType="USCore.Address" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="gender" elementType="USCore.AdministrativeGender" target="%value.value"/>
      <element name="birthDate" elementType="System.Date" target="%value.value"/>
      <element name="photo">
         <elementTypeSpecifier elementType="USCore.Attachment" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="qualification">
         <elementTypeSpecifier elementType="USCore.Practitioner.Qualification" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="communication" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="PractitionerRole.AvailableTime" retrievable="false">
      <element name="daysOfWeek" target="%value.value">
         <elementTypeSpecifier elementType="USCore.DaysOfWeek" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="allDay" elementType="System.Boolean" target="%value.value"/>
      <element name="availableStartTime" elementType="System.Time" target="%value.value"/>
      <element name="availableEndTime" elementType="System.Time" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="PractitionerRole.NotAvailable" retrievable="false">
      <element name="description" elementType="System.String" target="%value.value"/>
      <element name="during" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="PractitionerRoleProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitionerrole" label="US Core PractitionerRole Profile" target="PractitionerRole" retrievable="true">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="active" elementType="System.Boolean" target="%value.value"/>
      <element name="period" target="FHIRHelpers.ToInterval(%value)">
         <elementTypeSpecifier xsi:type="IntervalTypeSpecifier">
            <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="practitioner" elementType="USCore.Reference"/>
      <element name="organization" elementType="USCore.Reference"/>
      <element name="code" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="specialty" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="location">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="healthcareService">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="telecom">
         <elementTypeSpecifier elementType="USCore.ContactPoint" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="availableTime">
         <elementTypeSpecifier elementType="USCore.PractitionerRole.AvailableTime" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="notAvailable">
         <elementTypeSpecifier elementType="USCore.PractitionerRole.NotAvailable" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="availabilityExceptions" elementType="System.String" target="%value.value"/>
      <element name="endpoint">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Procedure.FocalDevice" retrievable="false">
      <element name="action" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="manipulated" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Procedure.Performer" retrievable="false">
      <element name="function" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="actor" elementType="USCore.Reference"/>
      <element name="onBehalfOf" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="ProcedureProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" label="US Core Procedure Profile" target="Procedure" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="instantiatesCanonical" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="instantiatesUri" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="statusReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="category" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="performed" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="recorder" elementType="USCore.Reference"/>
      <element name="asserter" elementType="USCore.Reference"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Procedure.Performer" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="location" elementType="USCore.Reference"/>
      <element name="reasonCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="reasonReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="outcome" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="report">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="complication" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="complicationDetail">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="followUp" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="focalDevice">
         <elementTypeSpecifier elementType="USCore.Procedure.FocalDevice" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="usedReference">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="usedCode" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="Provenance" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-provenance" label="US Core Provenance Profile" retrievable="true">
      <element name="target">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="occurred" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="recorded" elementType="System.DateTime" target="%value.value"/>
      <element name="policy" target="%value.value">
         <elementTypeSpecifier elementType="System.String" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="location" elementType="USCore.Reference"/>
      <element name="reason" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="activity" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="agent">
         <elementTypeSpecifier elementType="USCore.Provenance.Agent" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="ProvenanceAuthor">
         <elementTypeSpecifier elementType="USCore.Provenance.Agent.ProvenanceAuthor" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="ProvenanceTransmitter" elementType="USCore.Provenance.Agent.ProvenanceTransmitter"/>
      <element name="entity">
         <elementTypeSpecifier elementType="USCore.Provenance.Entity" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="signature">
         <elementTypeSpecifier elementType="USCore.Signature" xsi:type="ListTypeSpecifier"/>
      </element>
      <contextRelationship context="Patient" relatedKeyElement="where(resolve() is Patient)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Provenance.Agent" retrievable="false">
      <element name="type" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="role" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="who" elementType="USCore.Reference"/>
      <element name="onBehalfOf" elementType="USCore.Reference"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Provenance.Agent" namespace="USCore" name="Provenance.Agent.ProvenanceAuthor" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Provenance.Agent" namespace="USCore" name="Provenance.Agent.ProvenanceTransmitter" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Provenance.Entity" retrievable="false">
      <element name="role" elementType="USCore.ProvenanceEntityRole" target="%value.value"/>
      <element name="what" elementType="USCore.Reference"/>
      <element name="agent">
         <elementTypeSpecifier xsi:type="ListTypeSpecifier">
            <elementTypeSpecifier namespace="USCore" name="Provenance.Agent.ProvenanceTransmitter" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="ProvenanceEntityRole" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="PulseOximetryProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry" label="US Core Pulse Oximetry Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="OxygenSatCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='2708-6'])"/>
      <element name="PulseOx" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='59408-5'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="FlowRate" elementType="USCore.Observation.Component"/>
      <element name="Concentration" elementType="USCore.Observation.Component"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="QuantityComparator" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Extension" namespace="USCore" name="RaceExtension" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-race" label="US Core Race Extension" retrievable="false">
      <element name="ombCategory" target="FHIRHelpers.ToCode(%parent.extension[url='ombCategory'].value)">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="detailed" target="FHIRHelpers.ToCode(%parent.extension[url='detailed'].value)">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="text" elementType="System.String" target="%parent.extension[url='text'].value.value"/>
      <element name="url" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Reference" identifier="http://hl7.org/fhir/StructureDefinition/Reference" label="Reference" retrievable="false">
      <element name="reference" elementType="System.String" target="%value.value"/>
      <element name="type" elementType="System.String" target="%value.value"/>
      <element name="identifier" elementType="USCore.Identifier"/>
      <element name="display" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="ReferredDocumentStatus" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="RelatedArtifact" identifier="http://hl7.org/fhir/StructureDefinition/RelatedArtifact" label="RelatedArtifact" retrievable="false">
      <element name="type" elementType="USCore.RelatedArtifactType" target="%value.value"/>
      <element name="label" elementType="System.String" target="%value.value"/>
      <element name="display" elementType="System.String" target="%value.value"/>
      <element name="citation" elementType="System.String" target="%value.value"/>
      <element name="url" elementType="System.String" target="%value.value"/>
      <element name="document" elementType="USCore.Attachment"/>
      <element name="resource" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="RelatedArtifactType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.Any" namespace="USCore" name="Resource" identifier="http://hl7.org/fhir/StructureDefinition/Resource" label="Resource" retrievable="true">
      <element name="id" elementType="System.String" target="%value.value"/>
      <element name="meta" elementType="USCore.Meta"/>
      <element name="implicitRules" elementType="System.String" target="%value.value"/>
      <element name="language" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="SampledData" identifier="http://hl7.org/fhir/StructureDefinition/SampledData" label="SampledData" retrievable="false">
      <element name="origin" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="period" elementType="System.Decimal" target="%value.value"/>
      <element name="factor" elementType="System.Decimal" target="%value.value"/>
      <element name="lowerLimit" elementType="System.Decimal" target="%value.value"/>
      <element name="upperLimit" elementType="System.Decimal" target="%value.value"/>
      <element name="dimensions" elementType="System.Integer" target="%value.value"/>
      <element name="data" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Signature" identifier="http://hl7.org/fhir/StructureDefinition/Signature" label="Signature" retrievable="false">
      <element name="type" target="FHIRHelpers.ToCode(%value)">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="when" elementType="System.DateTime" target="%value.value"/>
      <element name="who" elementType="USCore.Reference"/>
      <element name="onBehalfOf" elementType="USCore.Reference"/>
      <element name="targetFormat" elementType="USCore.MimeType" target="%value.value"/>
      <element name="sigFormat" elementType="USCore.MimeType" target="%value.value"/>
      <element name="data" elementType="System.String" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="SmokingStatusProfile" identifier="http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus" label="US Core Smoking Status Observation Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="System.String" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="USCore" name="Timing" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="SortDirection" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="Status" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.BackboneElement" namespace="USCore" name="Timing" identifier="http://hl7.org/fhir/StructureDefinition/Timing" label="Timing" retrievable="false" primaryCodePath="code">
      <element name="event" target="%value.value">
         <elementTypeSpecifier elementType="System.DateTime" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="repeat" elementType="USCore.Timing.Repeat"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="Timing.Repeat" retrievable="false">
      <element name="bounds" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="count" elementType="System.Integer" target="%value.value"/>
      <element name="countMax" elementType="System.Integer" target="%value.value"/>
      <element name="duration" elementType="System.Decimal" target="%value.value"/>
      <element name="durationMax" elementType="System.Decimal" target="%value.value"/>
      <element name="durationUnit" elementType="USCore.UnitsOfTime" target="%value.value"/>
      <element name="frequency" elementType="System.Integer" target="%value.value"/>
      <element name="frequencyMax" elementType="System.Integer" target="%value.value"/>
      <element name="period" elementType="System.Decimal" target="%value.value"/>
      <element name="periodMax" elementType="System.Decimal" target="%value.value"/>
      <element name="periodUnit" elementType="USCore.UnitsOfTime" target="%value.value"/>
      <element name="dayOfWeek" target="%value.value">
         <elementTypeSpecifier elementType="USCore.DayOfWeek" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="timeOfDay" target="%value.value">
         <elementTypeSpecifier elementType="System.Time" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="when" target="%value.value">
         <elementTypeSpecifier elementType="USCore.EventTiming" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="offset" elementType="System.Integer" target="%value.value"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="TriggerDefinition" identifier="http://hl7.org/fhir/StructureDefinition/TriggerDefinition" label="TriggerDefinition" retrievable="false">
      <element name="type" elementType="USCore.TriggerType" target="%value.value"/>
      <element name="name" elementType="System.String" target="%value.value"/>
      <element name="timing" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="USCore" name="Timing" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Date" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
      <element name="data">
         <elementTypeSpecifier elementType="USCore.DataRequirement" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="condition" elementType="USCore.Expression"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="TriggerType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="UDIEntryType" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="System.String" namespace="USCore" name="UnitsOfTime" retrievable="false"/>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.Element" namespace="USCore" name="UsageContext" identifier="http://hl7.org/fhir/StructureDefinition/UsageContext" label="UsageContext" retrievable="false" primaryCodePath="code">
      <element name="code" elementType="System.Code" target="FHIRHelpers.ToCode(%value)"/>
      <element name="value" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="Concept" xsi:type="NamedTypeSpecifier"/>
            <choice namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="Quantity" xsi:type="NamedTypeSpecifier"/>
            </choice>
            <choice namespace="USCore" name="Reference" xsi:type="NamedTypeSpecifier"/>
         </elementTypeSpecifier>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-bmi" identifier="http://hl7.org/fhir/StructureDefinition/bmi" label="Observation Body Mass Index Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="BMICode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='39156-5'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-bodyheight" identifier="http://hl7.org/fhir/StructureDefinition/bodyheight" label="Observation Body Height Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="BodyHeightCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='8302-2'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-bodytemp" identifier="http://hl7.org/fhir/StructureDefinition/bodytemp" label="Observation Body Temperature Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="BodyTempCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='8310-5'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-bodyweight" identifier="http://hl7.org/fhir/StructureDefinition/bodyweight" label="Observation Body Weight Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="BodyWeightCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='29463-7'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-bp" identifier="http://hl7.org/fhir/StructureDefinition/bp" label="Observation Blood Pressure Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="BPCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='85354-9'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="SystolicBP" elementType="USCore.Observation.Component" target="%parent.component[code.coding.system='http://loinc.org',code.coding.code='8480-6']"/>
      <element name="DiastolicBP" elementType="USCore.Observation.Component" target="%parent.component[code.coding.system='http://loinc.org',code.coding.code='8462-4']"/>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-headcircum" identifier="http://hl7.org/fhir/StructureDefinition/headcircum" label="Observation Head Circumference Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="HeadCircumCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='9843-4'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-heartrate" identifier="http://hl7.org/fhir/StructureDefinition/heartrate" label="Observation Heart Rate Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="HeartRateCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='8867-4'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-oxygensat" identifier="http://hl7.org/fhir/StructureDefinition/oxygensat" label="Observation Oxygen Saturation Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="OxygenSatCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='2708-6'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-resprate" identifier="http://hl7.org/fhir/StructureDefinition/resprate" label="Observation Respiratory Rate Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="RespRateCode" elementType="System.Code" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='9279-1'])"/>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="value" elementType="System.Quantity" target="FHIRHelpers.ToQuantity(%value)"/>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <typeInfo xsi:type="ClassInfo" baseType="USCore.DomainResource" namespace="USCore" name="observation-vitalspanel" identifier="http://hl7.org/fhir/StructureDefinition/vitalspanel" label="Observation Vital Signs Panel Profile" target="Observation" retrievable="true" primaryCodePath="code">
      <element name="identifier">
         <elementTypeSpecifier elementType="USCore.Identifier" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="basedOn">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="partOf">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="status" elementType="USCore.Status" target="%value.value"/>
      <element name="category" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="VSCat" elementType="System.Concept" target="FHIRHelpers.ToConcept(%parent.category[coding.system='http://terminology.hl7.org/CodeSystem/observation-category',coding.code='vital-signs'])"/>
      <element name="code" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="VitalsPanelCode" target="FHIRHelpers.ToCode(%parent.code.coding[system='http://loinc.org',code='85353-1'])">
         <elementTypeSpecifier elementType="System.Code" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="subject" elementType="USCore.Reference"/>
      <element name="focus">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="encounter" elementType="USCore.Reference"/>
      <element name="effective" target="FHIRHelpers.ToValue(%value)">
         <elementTypeSpecifier xsi:type="ChoiceTypeSpecifier">
            <choice namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            <choice xsi:type="IntervalTypeSpecifier">
               <pointTypeSpecifier namespace="System" name="DateTime" xsi:type="NamedTypeSpecifier"/>
            </choice>
         </elementTypeSpecifier>
      </element>
      <element name="issued" elementType="System.DateTime" target="%value.value"/>
      <element name="performer">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="dataAbsentReason" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="interpretation" target="FHIRHelpers.ToConcept(%value)">
         <elementTypeSpecifier elementType="System.Concept" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="note">
         <elementTypeSpecifier elementType="USCore.Annotation" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="bodySite" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="method" elementType="System.Concept" target="FHIRHelpers.ToConcept(%value)"/>
      <element name="specimen" elementType="USCore.Reference"/>
      <element name="device" elementType="USCore.Reference"/>
      <element name="referenceRange">
         <elementTypeSpecifier elementType="USCore.Observation.ReferenceRange" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="hasMember">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="derivedFrom">
         <elementTypeSpecifier elementType="USCore.Reference" xsi:type="ListTypeSpecifier"/>
      </element>
      <element name="component">
         <elementTypeSpecifier elementType="USCore.Observation.Component" xsi:type="ListTypeSpecifier"/>
      </element>
   </typeInfo>
   <contextInfo name="Patient" keyElement="id" birthDateElement="birthDate">
      <contextType namespace="USCore" name="PatientProfile"/>
   </contextInfo>
</modelInfo>", + "url": "https://github.com/cqframework/clinical_quality_language/blob/master/Src/java/quick/src/main/resources/org/hl7/fhir/uscore-modelinfo-3.1.1.xml" + } ] +} \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreCommon.json b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreCommon.json new file mode 100644 index 000000000..e03ceb785 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreCommon.json @@ -0,0 +1,127 @@ +{ + "resourceType": "Library", + "id": "USCoreCommon", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/cqf/us/common/Library/USCoreCommon", + "version": "0.1.0", + "name": "USCoreCommon", + "relatedArtifact": [ { + "type": "depends-on", + "display": "USCore model information", + "resource": "http://hl7.org/fhir/Library/USCore-ModelInfo" + }, { + "type": "depends-on", + "display": "FHIR model information", + "resource": "http://fhir.org/guides/cqf/common/Library/FHIR-ModelInfo|4.0.1" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Code system LOINC", + "resource": "http://loinc.org" + }, { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, { + "type": "depends-on", + "display": "Code system CVX", + "resource": "http://hl7.org/fhir/sid/cvx" + }, { + "type": "depends-on", + "display": "Code system ActCode", + "resource": "http://terminology.hl7.org/CodeSystem/v3-ActCode" + }, { + "type": "depends-on", + "display": "Code system RoleCode", + "resource": "http://terminology.hl7.org/CodeSystem/v3-RoleCode" + }, { + "type": "depends-on", + "display": "Code system Diagnosis Role", + "resource": "http://terminology.hl7.org/CodeSystem/diagnosis-role" + }, { + "type": "depends-on", + "display": "Code system RequestIntent", + "resource": "http://hl7.org/fhir/request-intent" + }, { + "type": "depends-on", + "display": "Code system MedicationRequestCategory", + "resource": "http://terminology.hl7.org/CodeSystem/medicationrequest-category" + }, { + "type": "depends-on", + "display": "Code system ConditionClinicalStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/condition-clinical" + }, { + "type": "depends-on", + "display": "Code system ConditionVerificationStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/condition-ver-status" + }, { + "type": "depends-on", + "display": "Code system AllergyIntoleranceClinicalStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical" + }, { + "type": "depends-on", + "display": "Code system AllergyIntoleranceVerificationStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-verification" + }, { + "type": "depends-on", + "display": "Code system ObservationCategoryCodes", + "resource": "http://terminology.hl7.org/CodeSystem/observation-category" + }, { + "type": "depends-on", + "display": "Code system USCoreObservationCategory", + "resource": "http://hl7.org/fhir/us/core/CodeSystem/us-core-observation-category" + }, { + "type": "depends-on", + "display": "Code system ObservationStatusCodes", + "resource": "http://hl7.org/fhir/observation-status" + }, { + "type": "depends-on", + "display": "Code system ConditionCategory", + "resource": "http://terminology.hl7.org/CodeSystem/condition-category" + }, { + "type": "depends-on", + "display": "Code system USCoreConditionCategory", + "resource": "http://hl7.org/fhir/us/core/CodeSystem/condition-category" + }, { + "type": "depends-on", + "display": "Code system CDC Race and Ethnicity Codes", + "resource": "urn:oid:2.16.840.1.113883.6.238" + }, { + "type": "depends-on", + "display": "Code system CommunicationCategoryCodeSystem", + "resource": "http://terminology.hl7.org/CodeSystem/communication-category" + }, { + "type": "depends-on", + "display": "Code system IdentifierType", + "resource": "http://terminology.hl7.org/CodeSystem/v2-0203" + } ], + "parameter": [ { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + } ], + "dataRequirement": [ { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "/*
@author: Bryn Rhodes
@description: This library defines functions to expose extensions defined
in QICore as fluent functions in CQL, as well as common terminology and functions
used in writing CQL with FHIR and QICore profiles.
*/
library USCoreCommon version '0.1.0'

using USCore version '3.1.1'
using FHIR version '4.0.1'

include FHIRHelpers version '4.1.000'

codesystem "LOINC": 'http://loinc.org'
codesystem "SNOMEDCT": 'http://snomed.info/sct'
codesystem "CVX": 'http://hl7.org/fhir/sid/cvx'
codesystem "ActCode": 'http://terminology.hl7.org/CodeSystem/v3-ActCode'
codesystem "RoleCode": 'http://terminology.hl7.org/CodeSystem/v3-RoleCode'
codesystem "Diagnosis Role": 'http://terminology.hl7.org/CodeSystem/diagnosis-role'
codesystem "RequestIntent": 'http://hl7.org/fhir/request-intent'
codesystem "MedicationRequestCategory": 'http://terminology.hl7.org/CodeSystem/medicationrequest-category'
codesystem "ConditionClinicalStatusCodes": 'http://terminology.hl7.org/CodeSystem/condition-clinical'
codesystem "ConditionVerificationStatusCodes": 'http://terminology.hl7.org/CodeSystem/condition-ver-status'
codesystem "AllergyIntoleranceClinicalStatusCodes": 'http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical'
codesystem "AllergyIntoleranceVerificationStatusCodes": 'http://terminology.hl7.org/CodeSystem/allergyintolerance-verification'
codesystem "ObservationCategoryCodes": 'http://terminology.hl7.org/CodeSystem/observation-category'
codesystem "USCoreObservationCategory": 'http://hl7.org/fhir/us/core/CodeSystem/us-core-observation-category'
codesystem "ObservationStatusCodes": 'http://hl7.org/fhir/observation-status'
codesystem "ConditionCategory": 'http://terminology.hl7.org/CodeSystem/condition-category'
codesystem "USCoreConditionCategory": 'http://hl7.org/fhir/us/core/CodeSystem/condition-category'
codesystem "CDC Race and Ethnicity Codes": 'urn:oid:2.16.840.1.113883.6.238'
codesystem "CommunicationCategoryCodeSystem": 'http://terminology.hl7.org/CodeSystem/communication-category'
codesystem "IdentifierType": 'http://terminology.hl7.org/CodeSystem/v2-0203'

code "MedicalRecordNumber": 'MR' from "IdentifierType" display 'Medical record number'

code "Birthdate": '21112-8' from "LOINC" display 'Birth date'
code "Dead": '419099009' from "SNOMEDCT" display 'Dead'
code "ER": 'ER' from "RoleCode" display 'Emergency room'
code "ICU": 'ICU' from "RoleCode" display 'Intensive care unit'
code "Billing": 'billing' from "Diagnosis Role" display 'Billing'

// Encounter Class Codes
code "ambulatory": 'AMB' from ActCode display 'ambulatory'
code "emergency": 'EMER' from ActCode display 'emergency'
code "field": 'FLD' from ActCode display 'field'
code "home health": 'HH' from ActCode display 'home health'
code "inpatient encounter": 'IMP' from ActCode display 'inpatient encounter'
code "inpatient acute": 'ACUTE' from ActCode display 'inpatient acute'
code "inpatient non-acute": 'NONAC' from ActCode display 'inpatient non-acute'
code "observation encounter": 'OBSENC' from ActCode display 'observation encounter'
code "pre-admission": 'PRENC' from ActCode display 'pre-admission'
code "short stay": 'SS' from ActCode display 'short stay'
code "virtual": 'VR' from ActCode display 'VR'

// Condition Category Codes
code "problem-list-item": 'problem-list-item' from "ConditionCategory" display 'Problem List Item'
code "encounter-diagnosis": 'encounter-diagnosis' from "ConditionCategory" display 'Encounter Diagnosis'
code "health-concern": 'health-concern' from "USCoreConditionCategory" display 'Health Concern'

// Condition Clinical Status Codes - Consider value sets for these
code "active": 'active' from "ConditionClinicalStatusCodes"
code "recurrence": 'recurrence' from "ConditionClinicalStatusCodes"
code "relapse": 'relapse' from "ConditionClinicalStatusCodes"
code "inactive": 'inactive' from "ConditionClinicalStatusCodes"
code "remission": 'remission' from "ConditionClinicalStatusCodes"
code "resolved": 'resolved' from "ConditionClinicalStatusCodes"

// Condition Verification Status Codes - Consider value sets for these
code "unconfirmed": 'unconfirmed' from ConditionVerificationStatusCodes
code "provisional": 'provisional' from ConditionVerificationStatusCodes
code "differential": 'differential' from ConditionVerificationStatusCodes
code "confirmed": 'confirmed' from ConditionVerificationStatusCodes
code "refuted": 'refuted' from ConditionVerificationStatusCodes
code "entered-in-error": 'entered-in-error' from ConditionVerificationStatusCodes

code "allergy-active": 'active' from "AllergyIntoleranceClinicalStatusCodes"
code "allergy-inactive": 'inactive' from "AllergyIntoleranceClinicalStatusCodes"
code "allergy-resolved": 'resolved' from "AllergyIntoleranceClinicalStatusCodes"

// Allergy/Intolerance Verification Status Codes - Consider value sets for these
code "allergy-unconfirmed": 'unconfirmed' from AllergyIntoleranceVerificationStatusCodes
code "allergy-confirmed": 'confirmed' from AllergyIntoleranceVerificationStatusCodes
code "allergy-refuted": 'refuted' from AllergyIntoleranceVerificationStatusCodes

// MedicationRequest Category Codes
code "Inpatient": 'inpatient' from "MedicationRequestCategory" display 'Inpatient'
code "Outpatient": 'outpatient' from "MedicationRequestCategory" display 'Outpatient'
code "Community": 'community' from "MedicationRequestCategory" display 'Community'
code "Discharge": 'discharge' from "MedicationRequestCategory" display 'Discharge'

// Diagnosis Role Codes
code "AD": 'AD' from "Diagnosis Role" display 'Admission diagnosis'
code "DD": 'DD' from "Diagnosis Role" display 'Discharge diagnosis'
code "CC": 'CC' from "Diagnosis Role" display 'Chief complaint'
code "CM": 'CM' from "Diagnosis Role" display 'Comorbidity diagnosis'
code "pre-op": 'pre-op' from "Diagnosis Role" display 'pre-op diagnosis'
code "post-op": 'post-op' from "Diagnosis Role" display 'post-op diagnosis'
code "billing": 'billing' from "Diagnosis Role" display 'billing diagnosis'

// Observation Category Codes
code "social-history": 'social-history' from "ObservationCategoryCodes" display 'Social History'
code "vital-signs": 'vital-signs' from "ObservationCategoryCodes" display 'Vital Signs'
code "imaging": 'imaging' from "ObservationCategoryCodes" display 'Imaging'
code "laboratory": 'laboratory' from "ObservationCategoryCodes" display 'Laboratory'
code "procedure": 'procedure' from "ObservationCategoryCodes" display 'Procedure'
code "survey": 'survey' from "ObservationCategoryCodes" display 'Survey'
code "exam": 'exam' from "ObservationCategoryCodes" display 'Exam'
code "therapy": 'therapy' from "ObservationCategoryCodes" display 'Therapy'
code "activity": 'activity' from "ObservationCategoryCodes" display 'Activity'
code "clinical-test": 'clinical-test' from "USCoreObservationCategory" display 'Clinical Test'

// Observation Status Codes
code "observation-registered": 'registered' from "ObservationStatusCodes" display 'Registered'
code "observation-preliminary": 'preliminary' from "ObservationStatusCodes" display 'Preliminary'
code "observation-final": 'final' from "ObservationStatusCodes" display 'Final'
code "observation-amended": 'amended' from "ObservationStatusCodes" display 'Amended'
code "observation-corrected": 'corrected' from "ObservationStatusCodes" display 'Corrected'
code "observation-cancelled": 'cancelled' from "ObservationStatusCodes" display 'Cancelled'
code "observation-entered-in-error": 'entered-in-error' from "ObservationStatusCodes" display 'Entered in Error'
code "observation-unknown": 'unknown' from "ObservationStatusCodes" display 'Unknown'

context Patient

/* Candidates for FHIRCommon */

/*
@description: Returns true if the given condition has a clinical status of active, recurrence, or relapse
*/
define fluent function isActive(condition USCore.Condition):
  condition.clinicalStatus ~ "active"
    or condition.clinicalStatus ~ "recurrence"
    or condition.clinicalStatus ~ "relapse"

define fluent function active(conditions List<USCore.Condition>):
  conditions C
    where C.clinicalStatus ~ "active"
      or C.clinicalStatus ~ "recurrence"
      or C.clinicalStatus ~ "relapse"

define fluent function isAllergyActive(allergyIntolerance USCore.AllergyIntolerance):
  allergyIntolerance.clinicalStatus ~ "allergy-active"

define fluent function allergyActive(allergyIntolerances List<USCore.AllergyIntolerance>):
  allergyIntolerances A
    where A.clinicalStatus ~ "allergy-active"

define fluent function isAllergyInactive(allergyIntolerance USCore.AllergyIntolerance):
  allergyIntolerance.clinicalStatus ~ "allergy-inactive"

define fluent function allergyInactive(allergyIntolerances List<USCore.AllergyIntolerance>):
  allergyIntolerances A
    where A.clinicalStatus ~ "allergy-inactive"

define fluent function isAllergyResolved(allergyIntolerance USCore.AllergyIntolerance):
  allergyIntolerance.clinicalStatus ~ "allergy-resolved"

define fluent function allergyResolved(allergyIntolerances List<USCore.AllergyIntolerance>):
  allergyIntolerances A
    where A.clinicalStatus ~ "allergy-resolved"

define fluent function isAllergyConfirmed(allergyIntolerance USCore.AllergyIntolerance):
  allergyIntolerance.verificationStatus ~ "allergy-confirmed"

define fluent function allergyConfirmed(allergyIntolerances List<USCore.AllergyIntolerance>):
  allergyIntolerances A
    where A.verificationStatus ~ "allergy-confirmed"

define fluent function isAllergyUnconfirmed(allergyIntolerance USCore.AllergyIntolerance):
  allergyIntolerance.verificationStatus ~ "allergy-unconfirmed"

define fluent function allergyUnconfirmed(allergyIntolerances USCore.AllergyIntolerance):
  allergyIntolerances A
    where A.verificationStatus ~ "allergy-unconfirmed"

define fluent function isAllergyRefuted(allergyIntolerance USCore.AllergyIntolerance):
  allergyIntolerance.verificationStatus ~ "allergy-refuted"

define fluent function allergyRefuted(allergyIntolerances USCore.AllergyIntolerance):
  allergyIntolerances A
    where A.verificationStatus ~ "allergy-refuted"

/*
@description: Returns true if the given condition has the given category
*/
define fluent function hasCategory(condition USCore.Condition, category Code):
  exists (condition.category C
    where C ~ category
  )

/*
@description: Returns true if the given condition is a problem list item.
*/
define fluent function isProblemListItem(condition USCore.Condition):
  exists (condition.category C
    where C ~ "problem-list-item"
  )

/*
@description: Returns true if the given condition is an encounter diagnosis
*/
define fluent function isEncounterDiagnosis(condition USCore.Condition):
  exists (condition.category C
    where C ~ "encounter-diagnosis"
  )

/*
@description: Returns true if the given condition is a health concern
*/
define fluent function isHealthConcern(condition USCore.Condition):
  exists (condition.category C
    where C ~ "health-concern"
  )

define fluent function isUnconfirmed(condition USCore.Condition):
  condition.verificationStatus ~ "unconfirmed"

define fluent function unconfirmed(conditions List<USCore.Condition>):
  conditions C
    where C.verificationStatus ~ "unconfirmed"

define fluent function isProvisional(condition USCore.Condition):
  condition.verificationStatus ~ "provisional"

define fluent function provisional(conditions List<USCore.Condition>):
  conditions C
    where C.verificationStatus ~ "provisional"

define fluent function isDifferential(condition USCore.Condition):
  condition.verificationStatus ~ "differential"

define fluent function differential(conditions List<USCore.Condition>):
  conditions C
    where C.verificationStatus ~ "differential"

define fluent function isConfirmed(condition USCore.Condition):
  condition.verificationStatus ~ "confirmed"

define fluent function confirmed(conditions List<USCore.Condition>):
  conditions C
    where C.verificationStatus ~ "confirmed"

define fluent function isRefuted(condition USCore.Condition):
  condition.verificationStatus ~ "refuted"

define fluent function refuted(conditions List<USCore.Condition>):
  conditions C
    where C.verificationStatus ~ "refuted"

/*
@description: Returns true if the given observation has the given category
*/
define fluent function hasCategory(observation LaboratoryResultObservationProfile, category Code):
  exists (observation.category C
    where C ~ category
  )

/*
@description: Returns true if the given observation has status
*/
define fluent function isResulted(observation LaboratoryResultObservationProfile):
  observation.status ~ "observation-final".code
    or observation.status ~ "observation-amended".code
    or observation.status ~ "observation-corrected".code

define fluent function resulted(observations List<LaboratoryResultObservationProfile>):
  observations observation
    where observation.status ~ "observation-final".code
      or observation.status ~ "observation-amended".code
      or observation.status ~ "observation-corrected".code

define fluent function isFinal(observation LaboratoryResultObservationProfile):
  observation.status ~ "observation-final".code

define fluent function final(observations List<LaboratoryResultObservationProfile>):
  observations observation
    where observation.status ~ "observation-final".code

define fluent function isAmended(observation LaboratoryResultObservationProfile):
  observation.status ~ "observation-amended".code

define fluent function amended(observations List<LaboratoryResultObservationProfile>):
  observations observation
    where observation.status ~ "observation-amended".code

define fluent function isCorrected(observation LaboratoryResultObservationProfile):
  observation.status ~ "observation-corrected".code

define fluent function corrected(observations List<LaboratoryResultObservationProfile>):
  observations observation
    where observation.status ~ "observation-corrected".code


define fluent function isResulted(observation "observation-bodyweight"):
  observation.status ~ "observation-final".code
    or observation.status ~ "observation-amended".code
    or observation.status ~ "observation-corrected".code

define fluent function resulted(observations List<"observation-bodyweight">):
  observations observation
    where observation.status ~ "observation-final".code
      or observation.status ~ "observation-amended".code
      or observation.status ~ "observation-corrected".code

define fluent function isFinal(observation "observation-bodyweight"):
  observation.status ~ "observation-final".code

define fluent function final(observations List<"observation-bodyweight">):
  observations observation
    where observation.status ~ "observation-final".code

define fluent function isAmended(observation "observation-bodyweight"):
  observation.status ~ "observation-amended".code

define fluent function amended(observations List<"observation-bodyweight">):
  observations observation
    where observation.status ~ "observation-amended".code

define fluent function isCorrected(observation "observation-bodyweight"):
  observation.status ~ "observation-corrected".code

define fluent function corrected(observations List<"observation-bodyweight">):
  observations observation
    where observation.status ~ "observation-corrected".code


define fluent function isResulted(observation "observation-bodyheight"):
  observation.status ~ "observation-final".code
    or observation.status ~ "observation-amended".code
    or observation.status ~ "observation-corrected".code

define fluent function resulted(observations List<"observation-bodyheight">):
  observations observation
    where observation.status ~ "observation-final".code
      or observation.status ~ "observation-amended".code
      or observation.status ~ "observation-corrected".code

define fluent function isFinal(observation "observation-bodyheight"):
  observation.status ~ "observation-final".code

define fluent function final(observations List<"observation-bodyheight">):
  observations observation
    where observation.status ~ "observation-final".code

define fluent function isAmended(observation "observation-bodyheight"):
  observation.status ~ "observation-amended".code

define fluent function amended(observations List<"observation-bodyheight">):
  observations observation
    where observation.status ~ "observation-amended".code

define fluent function isCorrected(observation "observation-bodyheight"):
  observation.status ~ "observation-corrected".code

define fluent function corrected(observations List<"observation-bodyheight">):
  observations observation
    where observation.status ~ "observation-corrected".code
    return observation.status

/*
@description: Returns true if the given MedicationRequest has a category of Community
*/
define fluent function isCommunity(medicationRequest MedicationRequestProfile):
  exists (medicationRequest.category C
    where C ~ Community
  )

/*
@description: Returns true if the given MedicationRequest has a category of Discharge
*/
define fluent function isDischarge(medicationRequest MedicationRequestProfile):
  exists (medicationRequest.category C
    where C ~ Discharge
  )

/*
@description: Returns true if the given MedicationRequest has the given category
*/
define fluent function hasCategory(medicationRequest MedicationRequestProfile, category Code):
  exists (medicationRequest.category C
    where C ~ category
  )

/*
@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval
@comment: Normalizes a choice type of DateTime, Quanitty, Interval<DateTime>, or Interval<Quantity> types
to an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible
representations for timing-valued elements in QICore, allowing this function to be used across any resource.
The input can be provided as a DateTime, Quantity, Interval<DateTime> or Interval<Quantity>.
The intent of this function is to provide a clear and concise mechanism to treat single
elements that have multiple possible representations as intervals so that logic doesn't have to account
for the variability. More complex calculations (such as medication request period or dispense period
calculation) need specific guidance and consideration. That guidance may make use of this function, but
the focus of this function is on single element calculations where the semantics are unambiguous.
If the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.
If the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,
and the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.
If the input is a DateTime Interval, the result is the input.
If the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result
is a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending
immediately before one year later than the date the patient turned the age given as the end of the quantity interval.
Any other input will reslt in a null DateTime Interval
*/
define fluent function toInterval(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>>):
  case
	  when choice is DateTime then
    	Interval[choice as DateTime, choice as DateTime]
		when choice is Interval<DateTime> then
  		choice as Interval<DateTime>
		when choice is Quantity then
		  Interval[Patient.birthDate + (choice as Quantity),
			  Patient.birthDate + (choice as Quantity) + 1 year)
		when choice is Interval<Quantity> then
		  Interval[Patient.birthDate + (choice.low as Quantity),
			  Patient.birthDate + (choice.high as Quantity) + 1 year)
		else
			null as Interval<DateTime>
	end

/*
@description: Returns an interval representing the normalized abatement of a given Condition.
@comment: If the abatement element of the Condition is represented as a DateTime, the result
is an interval beginning and ending on that DateTime.
If the abatement is represented as a Quantity, the quantity is expected to be a calendar-duration and is interpreted as the age of the patient. The
result is an interval from the date the patient turned that age to immediately before one year later.
If the abatement is represented as a Quantity Interval, the quantities are expected to be calendar-durations and are interpreted as an age range during
which the abatement occurred. The result is an interval from the date the patient turned the starting age of the quantity interval, and ending immediately
before one year later than the date the patient turned the ending age of the quantity interval.
*/
define fluent function abatementInterval(condition USCore.Condition):
	if condition.abatement is DateTime then
	  Interval[condition.abatement as DateTime, condition.abatement as DateTime]
	else if condition.abatement is System.Quantity then
		Interval[Patient.birthDate + (condition.abatement as System.Quantity),
			Patient.birthDate + (condition.abatement as System.Quantity) + 1 year)
	else if condition.abatement is Interval<System.Quantity> then
	  Interval[Patient.birthDate + (condition.abatement.low as System.Quantity),
		  Patient.birthDate + (condition.abatement.high as System.Quantity) + 1 year)
	else if condition.abatement is Interval<DateTime> then
	  Interval[condition.abatement.low, condition.abatement.high)
	else null as Interval<DateTime>

/*
@description: Returns an interval representing the normalized prevalence period of a given Condition.
@comment: Uses the toInterval and abatementInterval functions to determine the widest potential interval from
onset to abatement as specified in the given Condition. If the condition is active, the resulting interval will have
a closed ending boundary. If the condition is not active, the resulting interval will have an open ending boundary.
*/
define fluent function prevalenceInterval(condition USCore.Condition):
if condition.clinicalStatus ~ "active"
  or condition.clinicalStatus ~ "recurrence"
  or condition.clinicalStatus ~ "relapse" then
  Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]
else
  Interval[start of condition.onset.toInterval(), end of condition.abatementInterval())

/*
@description: Returns the tail of the given uri (i.e. everything after the last slash in the URI).
@comment: This function can be used to determine the logical id of a given resource. It can be used in
a single-server environment to trace references. However, this function does not attempt to resolve
or distinguish the base of the given url, and so cannot be used safely in multi-server environments.
*/
define fluent function getId(uri String):
  Last(Split(uri, '/'))

/*
@description: Given an interval, return true if the interval has a starting boundary specified
(i.e. the start of the interval is not null and not the minimum DateTime value)
*/
define fluent function hasStart(period Interval<DateTime> ):
  not ( start of period is null
      or start of period = minimum DateTime
  )

/*
@description: Given an interval, returns true if the interval has an ending boundary specified
(i.e. the end of the interval is not null and not the maximum DateTime value)
*/
define fluent function hasEnd(period Interval<DateTime> ):
  not (
    end of period is null
      or end of period = maximum DateTime
  )

/*
@description: Given an interval, returns the ending point if the interval has an ending boundary specified,
otherwise, returns the starting point
*/
define fluent function latest(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>> ):
  (choice.toInterval()) period
    return
      if (period.hasEnd()) then end of period
      else start of period

/*
@description: Given an interval, return the starting point if the interval has a starting boundary specified,
otherwise, return the ending point
*/
define fluent function earliest(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>> ):
  (choice.toInterval()) period
    return
      if (period.hasStart()) then start of period
      else end of period

/*
@description: Returns the most recent Condition
*/
define function MostRecent(conditions List<USCore.Condition>):
  Last(
    conditions C
      sort by recordedDate
  )

/*
@description: Return the most recent Observation
*/
define function MostRecent(observations List<Observation>):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"SmokingStatusProfile">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"PulseOximetryProfile">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"PediatricWeightForHeightObservationProfile">):
  Last(
    observations O
      sort by issued
  )

  define function MostRecent(observations List<"PediatricBMIforAgeObservationProfile">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"LaboratoryResultObservationProfile">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"observation-vitalspanel">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"observation-resprate">):
  Last(
    observations O
      sort by issued
  )
  
  define function MostRecent(observations List<"observation-heartrate">):
  Last(
    observations O
      sort by issued
  )

  define function MostRecent(observations List<"observation-oxygensat">):
  Last(
    observations O
      sort by issued
  )

  define function MostRecent(observations List<"observation-bodytemp">):
  Last(
    observations O
      sort by issued
  )

  define function MostRecent(observations List<"observation-headcircum">):
  Last(
    observations O
      sort by issued
  )

  define function MostRecent(observations List<"observation-bp">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"observation-bmi">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"observation-bodyheight">):
  Last(
    observations O
      sort by issued
  )

define function MostRecent(observations List<"observation-bodyweight">):
  Last(
    observations O
      sort by issued
  )

define function MostRecentMR(medicationRequests List<"MedicationRequestProfile">):
  Last(
    medicationRequests MR
      sort by authoredOn
  )

define function MostRecentSR(serviceRequests List<FHIR.ServiceRequest>):
  Last(
    serviceRequests SR
      sort by (FHIRHelpers.ToDateTime(authoredOn) as DateTime)
  )


define function Mobile(contactPoints List<USCore.ContactPoint>):
  singleton from (contactPoints P where P.use = 'mobile')

" + }, { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1">
   <annotation translatorVersion="2.7.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:t name="author" value="Bryn Rhodes"/>
      <a:t name="description" value="This library defines functions to expose extensions defined&#xa;in QICore as fluent functions in CQL, as well as common terminology and functions&#xa;used in writing CQL with FHIR and QICore profiles."/>
      <a:s r="1197">
         <a:s>/*
@author: Bryn Rhodes
@description: This library defines functions to expose extensions defined
in QICore as fluent functions in CQL, as well as common terminology and functions
used in writing CQL with FHIR and QICore profiles.
*/
library USCoreCommon version '0.1.0'</a:s>
      </a:s>
   </annotation>
   <identifier id="USCoreCommon" system="http://fhir.org/guides/cqf/us/common" version="0.1.0"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="9:1-9:28" localIdentifier="USCore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="1">
               <a:s>using </a:s>
               <a:s>
                  <a:s>USCore</a:s>
               </a:s>
               <a:s> version '3.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="2" locator="10:1-10:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1">
         <annotation xsi:type="a:Annotation">
            <a:s r="2">
               <a:s>using </a:s>
               <a:s>
                  <a:s>FHIR</a:s>
               </a:s>
               <a:s> version '4.0.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="3" locator="12:1-12:37" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/cqf/us/common/FHIRHelpers" version="4.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="3">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.1.000'</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <codeSystems>
      <def localId="4" locator="14:1-14:38" name="LOINC" id="http://loinc.org" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="4">
               <a:s>codesystem &quot;LOINC&quot;: 'http://loinc.org'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="5" locator="15:1-15:47" name="SNOMEDCT" id="http://snomed.info/sct" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="5">
               <a:s>codesystem &quot;SNOMEDCT&quot;: 'http://snomed.info/sct'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="6" locator="16:1-16:47" name="CVX" id="http://hl7.org/fhir/sid/cvx" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="6">
               <a:s>codesystem &quot;CVX&quot;: 'http://hl7.org/fhir/sid/cvx'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="7" locator="17:1-17:72" name="ActCode" id="http://terminology.hl7.org/CodeSystem/v3-ActCode" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="7">
               <a:s>codesystem &quot;ActCode&quot;: 'http://terminology.hl7.org/CodeSystem/v3-ActCode'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="8" locator="18:1-18:74" name="RoleCode" id="http://terminology.hl7.org/CodeSystem/v3-RoleCode" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="8">
               <a:s>codesystem &quot;RoleCode&quot;: 'http://terminology.hl7.org/CodeSystem/v3-RoleCode'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="9" locator="19:1-19:83" name="Diagnosis Role" id="http://terminology.hl7.org/CodeSystem/diagnosis-role" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="9">
               <a:s>codesystem &quot;Diagnosis Role&quot;: 'http://terminology.hl7.org/CodeSystem/diagnosis-role'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="10" locator="20:1-20:64" name="RequestIntent" id="http://hl7.org/fhir/request-intent" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="10">
               <a:s>codesystem &quot;RequestIntent&quot;: 'http://hl7.org/fhir/request-intent'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="11" locator="21:1-21:106" name="MedicationRequestCategory" id="http://terminology.hl7.org/CodeSystem/medicationrequest-category" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="11">
               <a:s>codesystem &quot;MedicationRequestCategory&quot;: 'http://terminology.hl7.org/CodeSystem/medicationrequest-category'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="12" locator="22:1-22:101" name="ConditionClinicalStatusCodes" id="http://terminology.hl7.org/CodeSystem/condition-clinical" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="12">
               <a:s>codesystem &quot;ConditionClinicalStatusCodes&quot;: 'http://terminology.hl7.org/CodeSystem/condition-clinical'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="13" locator="23:1-23:107" name="ConditionVerificationStatusCodes" id="http://terminology.hl7.org/CodeSystem/condition-ver-status" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="13">
               <a:s>codesystem &quot;ConditionVerificationStatusCodes&quot;: 'http://terminology.hl7.org/CodeSystem/condition-ver-status'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="14" locator="24:1-24:119" name="AllergyIntoleranceClinicalStatusCodes" id="http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="14">
               <a:s>codesystem &quot;AllergyIntoleranceClinicalStatusCodes&quot;: 'http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="15" locator="25:1-25:127" name="AllergyIntoleranceVerificationStatusCodes" id="http://terminology.hl7.org/CodeSystem/allergyintolerance-verification" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="15">
               <a:s>codesystem &quot;AllergyIntoleranceVerificationStatusCodes&quot;: 'http://terminology.hl7.org/CodeSystem/allergyintolerance-verification'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="16" locator="26:1-26:99" name="ObservationCategoryCodes" id="http://terminology.hl7.org/CodeSystem/observation-category" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="16">
               <a:s>codesystem &quot;ObservationCategoryCodes&quot;: 'http://terminology.hl7.org/CodeSystem/observation-category'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="17" locator="27:1-27:109" name="USCoreObservationCategory" id="http://hl7.org/fhir/us/core/CodeSystem/us-core-observation-category" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="17">
               <a:s>codesystem &quot;USCoreObservationCategory&quot;: 'http://hl7.org/fhir/us/core/CodeSystem/us-core-observation-category'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="18" locator="28:1-28:77" name="ObservationStatusCodes" id="http://hl7.org/fhir/observation-status" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="18">
               <a:s>codesystem &quot;ObservationStatusCodes&quot;: 'http://hl7.org/fhir/observation-status'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="19" locator="29:1-29:90" name="ConditionCategory" id="http://terminology.hl7.org/CodeSystem/condition-category" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="19">
               <a:s>codesystem &quot;ConditionCategory&quot;: 'http://terminology.hl7.org/CodeSystem/condition-category'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="20" locator="30:1-30:97" name="USCoreConditionCategory" id="http://hl7.org/fhir/us/core/CodeSystem/condition-category" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="20">
               <a:s>codesystem &quot;USCoreConditionCategory&quot;: 'http://hl7.org/fhir/us/core/CodeSystem/condition-category'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="21" locator="31:1-31:76" name="CDC Race and Ethnicity Codes" id="urn:oid:2.16.840.1.113883.6.238" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="21">
               <a:s>codesystem &quot;CDC Race and Ethnicity Codes&quot;: 'urn:oid:2.16.840.1.113883.6.238'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="22" locator="32:1-32:108" name="CommunicationCategoryCodeSystem" id="http://terminology.hl7.org/CodeSystem/communication-category" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="22">
               <a:s>codesystem &quot;CommunicationCategoryCodeSystem&quot;: 'http://terminology.hl7.org/CodeSystem/communication-category'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="23" locator="33:1-33:76" name="IdentifierType" id="http://terminology.hl7.org/CodeSystem/v2-0203" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="23">
               <a:s>codesystem &quot;IdentifierType&quot;: 'http://terminology.hl7.org/CodeSystem/v2-0203'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <codes>
      <def localId="25" locator="35:1-35:86" name="MedicalRecordNumber" id="MR" display="Medical record number" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="25">
               <a:s>code &quot;MedicalRecordNumber&quot;: 'MR' from </a:s>
               <a:s r="24">
                  <a:s>&quot;IdentifierType&quot;</a:s>
               </a:s>
               <a:s> display 'Medical record number'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="24" locator="35:39-35:54" name="IdentifierType"/>
      </def>
      <def localId="27" locator="37:1-37:61" name="Birthdate" id="21112-8" display="Birth date" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="27">
               <a:s>code &quot;Birthdate&quot;: '21112-8' from </a:s>
               <a:s r="26">
                  <a:s>&quot;LOINC&quot;</a:s>
               </a:s>
               <a:s> display 'Birth date'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="26" locator="37:34-37:40" name="LOINC"/>
      </def>
      <def localId="29" locator="38:1-38:55" name="Dead" id="419099009" display="Dead" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="29">
               <a:s>code &quot;Dead&quot;: '419099009' from </a:s>
               <a:s r="28">
                  <a:s>&quot;SNOMEDCT&quot;</a:s>
               </a:s>
               <a:s> display 'Dead'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="28" locator="38:31-38:40" name="SNOMEDCT"/>
      </def>
      <def localId="31" locator="39:1-39:56" name="ER" id="ER" display="Emergency room" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="31">
               <a:s>code &quot;ER&quot;: 'ER' from </a:s>
               <a:s r="30">
                  <a:s>&quot;RoleCode&quot;</a:s>
               </a:s>
               <a:s> display 'Emergency room'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="30" locator="39:22-39:31" name="RoleCode"/>
      </def>
      <def localId="33" locator="40:1-40:63" name="ICU" id="ICU" display="Intensive care unit" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="33">
               <a:s>code &quot;ICU&quot;: 'ICU' from </a:s>
               <a:s r="32">
                  <a:s>&quot;RoleCode&quot;</a:s>
               </a:s>
               <a:s> display 'Intensive care unit'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="32" locator="40:24-40:33" name="RoleCode"/>
      </def>
      <def localId="35" locator="41:1-41:65" name="Billing" id="billing" display="Billing" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="35">
               <a:s>code &quot;Billing&quot;: 'billing' from </a:s>
               <a:s r="34">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'Billing'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="34" locator="41:32-41:47" name="Diagnosis Role"/>
      </def>
      <def localId="37" locator="44:1-44:58" name="ambulatory" id="AMB" display="ambulatory" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="37">
               <a:s>// Encounter Class Codes
code &quot;ambulatory&quot;: 'AMB' from </a:s>
               <a:s r="36">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'ambulatory'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="36" locator="44:31-44:37" name="ActCode"/>
      </def>
      <def localId="39" locator="45:1-45:57" name="emergency" id="EMER" display="emergency" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="39">
               <a:s>code &quot;emergency&quot;: 'EMER' from </a:s>
               <a:s r="38">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'emergency'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="38" locator="45:31-45:37" name="ActCode"/>
      </def>
      <def localId="41" locator="46:1-46:48" name="field" id="FLD" display="field" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="41">
               <a:s>code &quot;field&quot;: 'FLD' from </a:s>
               <a:s r="40">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'field'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="40" locator="46:26-46:32" name="ActCode"/>
      </def>
      <def localId="43" locator="47:1-47:59" name="home health" id="HH" display="home health" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="43">
               <a:s>code &quot;home health&quot;: 'HH' from </a:s>
               <a:s r="42">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'home health'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="42" locator="47:31-47:37" name="ActCode"/>
      </def>
      <def localId="45" locator="48:1-48:76" name="inpatient encounter" id="IMP" display="inpatient encounter" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="45">
               <a:s>code &quot;inpatient encounter&quot;: 'IMP' from </a:s>
               <a:s r="44">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'inpatient encounter'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="44" locator="48:40-48:46" name="ActCode"/>
      </def>
      <def localId="47" locator="49:1-49:70" name="inpatient acute" id="ACUTE" display="inpatient acute" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="47">
               <a:s>code &quot;inpatient acute&quot;: 'ACUTE' from </a:s>
               <a:s r="46">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'inpatient acute'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="46" locator="49:38-49:44" name="ActCode"/>
      </def>
      <def localId="49" locator="50:1-50:78" name="inpatient non-acute" id="NONAC" display="inpatient non-acute" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="49">
               <a:s>code &quot;inpatient non-acute&quot;: 'NONAC' from </a:s>
               <a:s r="48">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'inpatient non-acute'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="48" locator="50:42-50:48" name="ActCode"/>
      </def>
      <def localId="51" locator="51:1-51:83" name="observation encounter" id="OBSENC" display="observation encounter" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="51">
               <a:s>code &quot;observation encounter&quot;: 'OBSENC' from </a:s>
               <a:s r="50">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'observation encounter'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="50" locator="51:45-51:51" name="ActCode"/>
      </def>
      <def localId="53" locator="52:1-52:66" name="pre-admission" id="PRENC" display="pre-admission" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="53">
               <a:s>code &quot;pre-admission&quot;: 'PRENC' from </a:s>
               <a:s r="52">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'pre-admission'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="52" locator="52:36-52:42" name="ActCode"/>
      </def>
      <def localId="55" locator="53:1-53:57" name="short stay" id="SS" display="short stay" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="55">
               <a:s>code &quot;short stay&quot;: 'SS' from </a:s>
               <a:s r="54">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'short stay'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="54" locator="53:30-53:36" name="ActCode"/>
      </def>
      <def localId="57" locator="54:1-54:46" name="virtual" id="VR" display="VR" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="57">
               <a:s>code &quot;virtual&quot;: 'VR' from </a:s>
               <a:s r="56">
                  <a:s>ActCode</a:s>
               </a:s>
               <a:s> display 'VR'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="56" locator="54:27-54:33" name="ActCode"/>
      </def>
      <def localId="59" locator="57:1-57:98" name="problem-list-item" id="problem-list-item" display="Problem List Item" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="59">
               <a:s>// Condition Category Codes
code &quot;problem-list-item&quot;: 'problem-list-item' from </a:s>
               <a:s r="58">
                  <a:s>&quot;ConditionCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Problem List Item'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="58" locator="57:52-57:70" name="ConditionCategory"/>
      </def>
      <def localId="61" locator="58:1-58:104" name="encounter-diagnosis" id="encounter-diagnosis" display="Encounter Diagnosis" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="61">
               <a:s>code &quot;encounter-diagnosis&quot;: 'encounter-diagnosis' from </a:s>
               <a:s r="60">
                  <a:s>&quot;ConditionCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Encounter Diagnosis'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="60" locator="58:56-58:74" name="ConditionCategory"/>
      </def>
      <def localId="63" locator="59:1-59:95" name="health-concern" id="health-concern" display="Health Concern" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="63">
               <a:s>code &quot;health-concern&quot;: 'health-concern' from </a:s>
               <a:s r="62">
                  <a:s>&quot;USCoreConditionCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Health Concern'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="62" locator="59:46-59:70" name="USCoreConditionCategory"/>
      </def>
      <def localId="65" locator="62:1-62:59" name="active" id="active" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="65">
               <a:s>// Condition Clinical Status Codes - Consider value sets for these
code &quot;active&quot;: 'active' from </a:s>
               <a:s r="64">
                  <a:s>&quot;ConditionClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="64" locator="62:30-62:59" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="67" locator="63:1-63:67" name="recurrence" id="recurrence" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="67">
               <a:s>code &quot;recurrence&quot;: 'recurrence' from </a:s>
               <a:s r="66">
                  <a:s>&quot;ConditionClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="66" locator="63:38-63:67" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="69" locator="64:1-64:61" name="relapse" id="relapse" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="69">
               <a:s>code &quot;relapse&quot;: 'relapse' from </a:s>
               <a:s r="68">
                  <a:s>&quot;ConditionClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="68" locator="64:32-64:61" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="71" locator="65:1-65:63" name="inactive" id="inactive" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="71">
               <a:s>code &quot;inactive&quot;: 'inactive' from </a:s>
               <a:s r="70">
                  <a:s>&quot;ConditionClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="70" locator="65:34-65:63" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="73" locator="66:1-66:65" name="remission" id="remission" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="73">
               <a:s>code &quot;remission&quot;: 'remission' from </a:s>
               <a:s r="72">
                  <a:s>&quot;ConditionClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="72" locator="66:36-66:65" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="75" locator="67:1-67:63" name="resolved" id="resolved" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="75">
               <a:s>code &quot;resolved&quot;: 'resolved' from </a:s>
               <a:s r="74">
                  <a:s>&quot;ConditionClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="74" locator="67:34-67:63" name="ConditionClinicalStatusCodes"/>
      </def>
      <def localId="77" locator="70:1-70:71" name="unconfirmed" id="unconfirmed" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="77">
               <a:s>// Condition Verification Status Codes - Consider value sets for these
code &quot;unconfirmed&quot;: 'unconfirmed' from </a:s>
               <a:s r="76">
                  <a:s>ConditionVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="76" locator="70:40-70:71" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="79" locator="71:1-71:71" name="provisional" id="provisional" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="79">
               <a:s>code &quot;provisional&quot;: 'provisional' from </a:s>
               <a:s r="78">
                  <a:s>ConditionVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="78" locator="71:40-71:71" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="81" locator="72:1-72:73" name="differential" id="differential" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="81">
               <a:s>code &quot;differential&quot;: 'differential' from </a:s>
               <a:s r="80">
                  <a:s>ConditionVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="80" locator="72:42-72:73" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="83" locator="73:1-73:67" name="confirmed" id="confirmed" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="83">
               <a:s>code &quot;confirmed&quot;: 'confirmed' from </a:s>
               <a:s r="82">
                  <a:s>ConditionVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="82" locator="73:36-73:67" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="85" locator="74:1-74:63" name="refuted" id="refuted" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="85">
               <a:s>code &quot;refuted&quot;: 'refuted' from </a:s>
               <a:s r="84">
                  <a:s>ConditionVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="84" locator="74:32-74:63" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="87" locator="75:1-75:81" name="entered-in-error" id="entered-in-error" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="87">
               <a:s>code &quot;entered-in-error&quot;: 'entered-in-error' from </a:s>
               <a:s r="86">
                  <a:s>ConditionVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="86" locator="75:50-75:81" name="ConditionVerificationStatusCodes"/>
      </def>
      <def localId="89" locator="77:1-77:76" name="allergy-active" id="active" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="89">
               <a:s>code &quot;allergy-active&quot;: 'active' from </a:s>
               <a:s r="88">
                  <a:s>&quot;AllergyIntoleranceClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="88" locator="77:38-77:76" name="AllergyIntoleranceClinicalStatusCodes"/>
      </def>
      <def localId="91" locator="78:1-78:80" name="allergy-inactive" id="inactive" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="91">
               <a:s>code &quot;allergy-inactive&quot;: 'inactive' from </a:s>
               <a:s r="90">
                  <a:s>&quot;AllergyIntoleranceClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="90" locator="78:42-78:80" name="AllergyIntoleranceClinicalStatusCodes"/>
      </def>
      <def localId="93" locator="79:1-79:80" name="allergy-resolved" id="resolved" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="93">
               <a:s>code &quot;allergy-resolved&quot;: 'resolved' from </a:s>
               <a:s r="92">
                  <a:s>&quot;AllergyIntoleranceClinicalStatusCodes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="92" locator="79:42-79:80" name="AllergyIntoleranceClinicalStatusCodes"/>
      </def>
      <def localId="95" locator="82:1-82:88" name="allergy-unconfirmed" id="unconfirmed" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="95">
               <a:s>// Allergy/Intolerance Verification Status Codes - Consider value sets for these
code &quot;allergy-unconfirmed&quot;: 'unconfirmed' from </a:s>
               <a:s r="94">
                  <a:s>AllergyIntoleranceVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="94" locator="82:48-82:88" name="AllergyIntoleranceVerificationStatusCodes"/>
      </def>
      <def localId="97" locator="83:1-83:84" name="allergy-confirmed" id="confirmed" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="97">
               <a:s>code &quot;allergy-confirmed&quot;: 'confirmed' from </a:s>
               <a:s r="96">
                  <a:s>AllergyIntoleranceVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="96" locator="83:44-83:84" name="AllergyIntoleranceVerificationStatusCodes"/>
      </def>
      <def localId="99" locator="84:1-84:80" name="allergy-refuted" id="refuted" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="99">
               <a:s>code &quot;allergy-refuted&quot;: 'refuted' from </a:s>
               <a:s r="98">
                  <a:s>AllergyIntoleranceVerificationStatusCodes</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="98" locator="84:40-84:80" name="AllergyIntoleranceVerificationStatusCodes"/>
      </def>
      <def localId="101" locator="87:1-87:82" name="Inpatient" id="inpatient" display="Inpatient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="101">
               <a:s>// MedicationRequest Category Codes
code &quot;Inpatient&quot;: 'inpatient' from </a:s>
               <a:s r="100">
                  <a:s>&quot;MedicationRequestCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Inpatient'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="100" locator="87:36-87:62" name="MedicationRequestCategory"/>
      </def>
      <def localId="103" locator="88:1-88:85" name="Outpatient" id="outpatient" display="Outpatient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="103">
               <a:s>code &quot;Outpatient&quot;: 'outpatient' from </a:s>
               <a:s r="102">
                  <a:s>&quot;MedicationRequestCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Outpatient'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="102" locator="88:38-88:64" name="MedicationRequestCategory"/>
      </def>
      <def localId="105" locator="89:1-89:82" name="Community" id="community" display="Community" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="105">
               <a:s>code &quot;Community&quot;: 'community' from </a:s>
               <a:s r="104">
                  <a:s>&quot;MedicationRequestCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Community'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="104" locator="89:36-89:62" name="MedicationRequestCategory"/>
      </def>
      <def localId="107" locator="90:1-90:82" name="Discharge" id="discharge" display="Discharge" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="107">
               <a:s>code &quot;Discharge&quot;: 'discharge' from </a:s>
               <a:s r="106">
                  <a:s>&quot;MedicationRequestCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Discharge'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="106" locator="90:36-90:62" name="MedicationRequestCategory"/>
      </def>
      <def localId="109" locator="93:1-93:67" name="AD" id="AD" display="Admission diagnosis" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="109">
               <a:s>// Diagnosis Role Codes
code &quot;AD&quot;: 'AD' from </a:s>
               <a:s r="108">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'Admission diagnosis'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="108" locator="93:22-93:37" name="Diagnosis Role"/>
      </def>
      <def localId="111" locator="94:1-94:67" name="DD" id="DD" display="Discharge diagnosis" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="111">
               <a:s>code &quot;DD&quot;: 'DD' from </a:s>
               <a:s r="110">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'Discharge diagnosis'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="110" locator="94:22-94:37" name="Diagnosis Role"/>
      </def>
      <def localId="113" locator="95:1-95:63" name="CC" id="CC" display="Chief complaint" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="113">
               <a:s>code &quot;CC&quot;: 'CC' from </a:s>
               <a:s r="112">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'Chief complaint'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="112" locator="95:22-95:37" name="Diagnosis Role"/>
      </def>
      <def localId="115" locator="96:1-96:69" name="CM" id="CM" display="Comorbidity diagnosis" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="115">
               <a:s>code &quot;CM&quot;: 'CM' from </a:s>
               <a:s r="114">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'Comorbidity diagnosis'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="114" locator="96:22-96:37" name="Diagnosis Role"/>
      </def>
      <def localId="117" locator="97:1-97:72" name="pre-op" id="pre-op" display="pre-op diagnosis" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="117">
               <a:s>code &quot;pre-op&quot;: 'pre-op' from </a:s>
               <a:s r="116">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'pre-op diagnosis'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="116" locator="97:30-97:45" name="Diagnosis Role"/>
      </def>
      <def localId="119" locator="98:1-98:75" name="post-op" id="post-op" display="post-op diagnosis" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="119">
               <a:s>code &quot;post-op&quot;: 'post-op' from </a:s>
               <a:s r="118">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'post-op diagnosis'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="118" locator="98:32-98:47" name="Diagnosis Role"/>
      </def>
      <def localId="121" locator="99:1-99:75" name="billing" id="billing" display="billing diagnosis" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="121">
               <a:s>code &quot;billing&quot;: 'billing' from </a:s>
               <a:s r="120">
                  <a:s>&quot;Diagnosis Role&quot;</a:s>
               </a:s>
               <a:s> display 'billing diagnosis'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="120" locator="99:32-99:47" name="Diagnosis Role"/>
      </def>
      <def localId="123" locator="102:1-102:96" name="social-history" id="social-history" display="Social History" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="123">
               <a:s>// Observation Category Codes
code &quot;social-history&quot;: 'social-history' from </a:s>
               <a:s r="122">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Social History'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="122" locator="102:46-102:71" name="ObservationCategoryCodes"/>
      </def>
      <def localId="125" locator="103:1-103:87" name="vital-signs" id="vital-signs" display="Vital Signs" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="125">
               <a:s>code &quot;vital-signs&quot;: 'vital-signs' from </a:s>
               <a:s r="124">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Vital Signs'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="124" locator="103:40-103:65" name="ObservationCategoryCodes"/>
      </def>
      <def localId="127" locator="104:1-104:75" name="imaging" id="imaging" display="Imaging" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="127">
               <a:s>code &quot;imaging&quot;: 'imaging' from </a:s>
               <a:s r="126">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Imaging'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="126" locator="104:32-104:57" name="ObservationCategoryCodes"/>
      </def>
      <def localId="129" locator="105:1-105:84" name="laboratory" id="laboratory" display="Laboratory" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="129">
               <a:s>code &quot;laboratory&quot;: 'laboratory' from </a:s>
               <a:s r="128">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Laboratory'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="128" locator="105:38-105:63" name="ObservationCategoryCodes"/>
      </def>
      <def localId="131" locator="106:1-106:81" name="procedure" id="procedure" display="Procedure" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="131">
               <a:s>code &quot;procedure&quot;: 'procedure' from </a:s>
               <a:s r="130">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Procedure'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="130" locator="106:36-106:61" name="ObservationCategoryCodes"/>
      </def>
      <def localId="133" locator="107:1-107:72" name="survey" id="survey" display="Survey" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="133">
               <a:s>code &quot;survey&quot;: 'survey' from </a:s>
               <a:s r="132">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Survey'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="132" locator="107:30-107:55" name="ObservationCategoryCodes"/>
      </def>
      <def localId="135" locator="108:1-108:66" name="exam" id="exam" display="Exam" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="135">
               <a:s>code &quot;exam&quot;: 'exam' from </a:s>
               <a:s r="134">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Exam'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="134" locator="108:26-108:51" name="ObservationCategoryCodes"/>
      </def>
      <def localId="137" locator="109:1-109:75" name="therapy" id="therapy" display="Therapy" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="137">
               <a:s>code &quot;therapy&quot;: 'therapy' from </a:s>
               <a:s r="136">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Therapy'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="136" locator="109:32-109:57" name="ObservationCategoryCodes"/>
      </def>
      <def localId="139" locator="110:1-110:78" name="activity" id="activity" display="Activity" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="139">
               <a:s>code &quot;activity&quot;: 'activity' from </a:s>
               <a:s r="138">
                  <a:s>&quot;ObservationCategoryCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Activity'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="138" locator="110:34-110:59" name="ObservationCategoryCodes"/>
      </def>
      <def localId="141" locator="111:1-111:94" name="clinical-test" id="clinical-test" display="Clinical Test" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="141">
               <a:s>code &quot;clinical-test&quot;: 'clinical-test' from </a:s>
               <a:s r="140">
                  <a:s>&quot;USCoreObservationCategory&quot;</a:s>
               </a:s>
               <a:s> display 'Clinical Test'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="140" locator="111:44-111:70" name="USCoreObservationCategory"/>
      </def>
      <def localId="143" locator="114:1-114:94" name="observation-registered" id="registered" display="Registered" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="143">
               <a:s>// Observation Status Codes
code &quot;observation-registered&quot;: 'registered' from </a:s>
               <a:s r="142">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Registered'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="142" locator="114:50-114:73" name="ObservationStatusCodes"/>
      </def>
      <def localId="145" locator="115:1-115:97" name="observation-preliminary" id="preliminary" display="Preliminary" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="145">
               <a:s>code &quot;observation-preliminary&quot;: 'preliminary' from </a:s>
               <a:s r="144">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Preliminary'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="144" locator="115:52-115:75" name="ObservationStatusCodes"/>
      </def>
      <def localId="147" locator="116:1-116:79" name="observation-final" id="final" display="Final" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="147">
               <a:s>code &quot;observation-final&quot;: 'final' from </a:s>
               <a:s r="146">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Final'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="146" locator="116:40-116:63" name="ObservationStatusCodes"/>
      </def>
      <def localId="149" locator="117:1-117:85" name="observation-amended" id="amended" display="Amended" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="149">
               <a:s>code &quot;observation-amended&quot;: 'amended' from </a:s>
               <a:s r="148">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Amended'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="148" locator="117:44-117:67" name="ObservationStatusCodes"/>
      </def>
      <def localId="151" locator="118:1-118:91" name="observation-corrected" id="corrected" display="Corrected" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="151">
               <a:s>code &quot;observation-corrected&quot;: 'corrected' from </a:s>
               <a:s r="150">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Corrected'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="150" locator="118:48-118:71" name="ObservationStatusCodes"/>
      </def>
      <def localId="153" locator="119:1-119:91" name="observation-cancelled" id="cancelled" display="Cancelled" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="153">
               <a:s>code &quot;observation-cancelled&quot;: 'cancelled' from </a:s>
               <a:s r="152">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Cancelled'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="152" locator="119:48-119:71" name="ObservationStatusCodes"/>
      </def>
      <def localId="155" locator="120:1-120:112" name="observation-entered-in-error" id="entered-in-error" display="Entered in Error" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="155">
               <a:s>code &quot;observation-entered-in-error&quot;: 'entered-in-error' from </a:s>
               <a:s r="154">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Entered in Error'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="154" locator="120:62-120:85" name="ObservationStatusCodes"/>
      </def>
      <def localId="157" locator="121:1-121:85" name="observation-unknown" id="unknown" display="Unknown" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="157">
               <a:s>code &quot;observation-unknown&quot;: 'unknown' from </a:s>
               <a:s r="156">
                  <a:s>&quot;ObservationStatusCodes&quot;</a:s>
               </a:s>
               <a:s> display 'Unknown'</a:s>
            </a:s>
         </annotation>
         <codeSystem localId="156" locator="121:44-121:67" name="ObservationStatusCodes"/>
      </def>
   </codes>
   <contexts>
      <def locator="123:1-123:15" name="Patient"/>
   </contexts>
   <statements>
      <def locator="123:1-123:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="123:1-123:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="173" locator="130:1-133:43" name="isActive" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given condition has a clinical status of active, recurrence, or relapse"/>
            <a:s r="173">
               <a:s>/* Candidates for FHIRCommon */

/*
@description: Returns true if the given condition has a clinical status of active, recurrence, or relapse
*/
define fluent function isActive(condition </a:s>
               <a:s r="158">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="172">
                  <a:s r="172">
                     <a:s r="167">
                        <a:s r="162">
                           <a:s r="160">
                              <a:s r="159">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="160">
                                 <a:s>clinicalStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="161">
                              <a:s>&quot;active&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    or </a:s>
                        <a:s r="166">
                           <a:s r="164">
                              <a:s r="163">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="164">
                                 <a:s>clinicalStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="165">
                              <a:s>&quot;recurrence&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="171">
                        <a:s r="169">
                           <a:s r="168">
                              <a:s>condition</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="169">
                              <a:s>clinicalStatus</a:s>
                           </a:s>
                        </a:s>
                        <a:s> ~ </a:s>
                        <a:s r="170">
                           <a:s>&quot;relapse&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="172" locator="131:3-133:43" xsi:type="Or">
            <operand localId="167" locator="131:3-132:46" xsi:type="Or">
               <operand localId="162" locator="131:3-131:37" xsi:type="Equivalent">
                  <operand localId="160" locator="131:3-131:26" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="clinicalStatus" xsi:type="Property">
                        <source localId="159" locator="131:3-131:11" name="condition" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
                  <operand xsi:type="ToConcept">
                     <operand localId="161" locator="131:30-131:37" name="active" xsi:type="CodeRef"/>
                  </operand>
               </operand>
               <operand localId="166" locator="132:8-132:46" xsi:type="Equivalent">
                  <operand localId="164" locator="132:8-132:31" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="clinicalStatus" xsi:type="Property">
                        <source localId="163" locator="132:8-132:16" name="condition" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
                  <operand xsi:type="ToConcept">
                     <operand localId="165" locator="132:35-132:46" name="recurrence" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </operand>
            <operand localId="171" locator="133:8-133:43" xsi:type="Equivalent">
               <operand localId="169" locator="133:8-133:31" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="clinicalStatus" xsi:type="Property">
                     <source localId="168" locator="133:8-133:16" name="condition" xsi:type="OperandRef"/>
                  </operand>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="170" locator="133:35-133:43" name="relapse" xsi:type="CodeRef"/>
               </operand>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="158" locator="130:43-130:58" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="193" locator="135:1-139:37" name="active" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="193">
               <a:s>define fluent function active(conditions </a:s>
               <a:s r="175">
                  <a:s>List&lt;</a:s>
                  <a:s r="174">
                     <a:s>USCore.Condition</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="192">
                  <a:s r="192">
                     <a:s>
                        <a:s r="177">
                           <a:s r="176">
                              <a:s>
                                 <a:s>conditions</a:s>
                              </a:s>
                           </a:s>
                           <a:s> C</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="191">
                        <a:s>where </a:s>
                        <a:s r="191">
                           <a:s r="186">
                              <a:s r="181">
                                 <a:s r="179">
                                    <a:s r="178">
                                       <a:s>C</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="179">
                                       <a:s>clinicalStatus</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="180">
                                    <a:s>&quot;active&quot;</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
      or </a:s>
                              <a:s r="185">
                                 <a:s r="183">
                                    <a:s r="182">
                                       <a:s>C</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="183">
                                       <a:s>clinicalStatus</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="184">
                                    <a:s>&quot;recurrence&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      or </a:s>
                           <a:s r="190">
                              <a:s r="188">
                                 <a:s r="187">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="188">
                                    <a:s>clinicalStatus</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="189">
                                 <a:s>&quot;relapse&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="192" locator="136:3-139:37" xsi:type="Query">
            <source localId="177" locator="136:3-136:14" alias="C">
               <expression localId="176" locator="136:3-136:12" name="conditions" xsi:type="OperandRef"/>
            </source>
            <where localId="191" locator="137:5-139:37" xsi:type="Or">
               <operand localId="186" locator="137:11-138:40" xsi:type="Or">
                  <operand localId="181" locator="137:11-137:37" xsi:type="Equivalent">
                     <operand localId="179" locator="137:11-137:26" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="clinicalStatus" scope="C" xsi:type="Property"/>
                     </operand>
                     <operand xsi:type="ToConcept">
                        <operand localId="180" locator="137:30-137:37" name="active" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
                  <operand localId="185" locator="138:10-138:40" xsi:type="Equivalent">
                     <operand localId="183" locator="138:10-138:25" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="clinicalStatus" scope="C" xsi:type="Property"/>
                     </operand>
                     <operand xsi:type="ToConcept">
                        <operand localId="184" locator="138:29-138:40" name="recurrence" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="190" locator="139:10-139:37" xsi:type="Equivalent">
                  <operand localId="188" locator="139:10-139:25" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="clinicalStatus" scope="C" xsi:type="Property"/>
                  </operand>
                  <operand xsi:type="ToConcept">
                     <operand localId="189" locator="139:29-139:37" name="relapse" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </where>
         </expression>
         <operand name="conditions">
            <operandTypeSpecifier localId="175" locator="135:42-135:63" xsi:type="ListTypeSpecifier">
               <elementType localId="174" locator="135:47-135:62" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="199" locator="141:1-142:54" name="isAllergyActive" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="199">
               <a:s>define fluent function isAllergyActive(allergyIntolerance </a:s>
               <a:s r="194">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="198">
                  <a:s r="198">
                     <a:s r="196">
                        <a:s r="195">
                           <a:s>allergyIntolerance</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="196">
                           <a:s>clinicalStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="197">
                        <a:s>&quot;allergy-active&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="198" locator="142:3-142:54" xsi:type="Equivalent">
            <operand localId="196" locator="142:3-142:35" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="clinicalStatus" xsi:type="Property">
                  <source localId="195" locator="142:3-142:20" name="allergyIntolerance" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="197" locator="142:39-142:54" name="allergy-active" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="allergyIntolerance">
            <operandTypeSpecifier localId="194" locator="141:59-141:83" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="209" locator="144:1-146:45" name="allergyActive" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="209">
               <a:s>define fluent function allergyActive(allergyIntolerances </a:s>
               <a:s r="201">
                  <a:s>List&lt;</a:s>
                  <a:s r="200">
                     <a:s>USCore.AllergyIntolerance</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="208">
                  <a:s r="208">
                     <a:s>
                        <a:s r="203">
                           <a:s r="202">
                              <a:s>
                                 <a:s>allergyIntolerances</a:s>
                              </a:s>
                           </a:s>
                           <a:s> A</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="207">
                        <a:s>where </a:s>
                        <a:s r="207">
                           <a:s r="205">
                              <a:s r="204">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="205">
                                 <a:s>clinicalStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="206">
                              <a:s>&quot;allergy-active&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="208" locator="145:3-146:45" xsi:type="Query">
            <source localId="203" locator="145:3-145:23" alias="A">
               <expression localId="202" locator="145:3-145:21" name="allergyIntolerances" xsi:type="OperandRef"/>
            </source>
            <where localId="207" locator="146:5-146:45" xsi:type="Equivalent">
               <operand localId="205" locator="146:11-146:26" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="clinicalStatus" scope="A" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="206" locator="146:30-146:45" name="allergy-active" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="allergyIntolerances">
            <operandTypeSpecifier localId="201" locator="144:58-144:88" xsi:type="ListTypeSpecifier">
               <elementType localId="200" locator="144:63-144:87" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="215" locator="148:1-149:56" name="isAllergyInactive" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="215">
               <a:s>define fluent function isAllergyInactive(allergyIntolerance </a:s>
               <a:s r="210">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="214">
                  <a:s r="214">
                     <a:s r="212">
                        <a:s r="211">
                           <a:s>allergyIntolerance</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="212">
                           <a:s>clinicalStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="213">
                        <a:s>&quot;allergy-inactive&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="214" locator="149:3-149:56" xsi:type="Equivalent">
            <operand localId="212" locator="149:3-149:35" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="clinicalStatus" xsi:type="Property">
                  <source localId="211" locator="149:3-149:20" name="allergyIntolerance" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="213" locator="149:39-149:56" name="allergy-inactive" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="allergyIntolerance">
            <operandTypeSpecifier localId="210" locator="148:61-148:85" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="225" locator="151:1-153:47" name="allergyInactive" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="225">
               <a:s>define fluent function allergyInactive(allergyIntolerances </a:s>
               <a:s r="217">
                  <a:s>List&lt;</a:s>
                  <a:s r="216">
                     <a:s>USCore.AllergyIntolerance</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="224">
                  <a:s r="224">
                     <a:s>
                        <a:s r="219">
                           <a:s r="218">
                              <a:s>
                                 <a:s>allergyIntolerances</a:s>
                              </a:s>
                           </a:s>
                           <a:s> A</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="223">
                        <a:s>where </a:s>
                        <a:s r="223">
                           <a:s r="221">
                              <a:s r="220">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="221">
                                 <a:s>clinicalStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="222">
                              <a:s>&quot;allergy-inactive&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="224" locator="152:3-153:47" xsi:type="Query">
            <source localId="219" locator="152:3-152:23" alias="A">
               <expression localId="218" locator="152:3-152:21" name="allergyIntolerances" xsi:type="OperandRef"/>
            </source>
            <where localId="223" locator="153:5-153:47" xsi:type="Equivalent">
               <operand localId="221" locator="153:11-153:26" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="clinicalStatus" scope="A" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="222" locator="153:30-153:47" name="allergy-inactive" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="allergyIntolerances">
            <operandTypeSpecifier localId="217" locator="151:60-151:90" xsi:type="ListTypeSpecifier">
               <elementType localId="216" locator="151:65-151:89" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="231" locator="155:1-156:56" name="isAllergyResolved" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="231">
               <a:s>define fluent function isAllergyResolved(allergyIntolerance </a:s>
               <a:s r="226">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="230">
                  <a:s r="230">
                     <a:s r="228">
                        <a:s r="227">
                           <a:s>allergyIntolerance</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="228">
                           <a:s>clinicalStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="229">
                        <a:s>&quot;allergy-resolved&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="230" locator="156:3-156:56" xsi:type="Equivalent">
            <operand localId="228" locator="156:3-156:35" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="clinicalStatus" xsi:type="Property">
                  <source localId="227" locator="156:3-156:20" name="allergyIntolerance" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="229" locator="156:39-156:56" name="allergy-resolved" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="allergyIntolerance">
            <operandTypeSpecifier localId="226" locator="155:61-155:85" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="241" locator="158:1-160:47" name="allergyResolved" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="241">
               <a:s>define fluent function allergyResolved(allergyIntolerances </a:s>
               <a:s r="233">
                  <a:s>List&lt;</a:s>
                  <a:s r="232">
                     <a:s>USCore.AllergyIntolerance</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="240">
                  <a:s r="240">
                     <a:s>
                        <a:s r="235">
                           <a:s r="234">
                              <a:s>
                                 <a:s>allergyIntolerances</a:s>
                              </a:s>
                           </a:s>
                           <a:s> A</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="239">
                        <a:s>where </a:s>
                        <a:s r="239">
                           <a:s r="237">
                              <a:s r="236">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="237">
                                 <a:s>clinicalStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="238">
                              <a:s>&quot;allergy-resolved&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="240" locator="159:3-160:47" xsi:type="Query">
            <source localId="235" locator="159:3-159:23" alias="A">
               <expression localId="234" locator="159:3-159:21" name="allergyIntolerances" xsi:type="OperandRef"/>
            </source>
            <where localId="239" locator="160:5-160:47" xsi:type="Equivalent">
               <operand localId="237" locator="160:11-160:26" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="clinicalStatus" scope="A" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="238" locator="160:30-160:47" name="allergy-resolved" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="allergyIntolerances">
            <operandTypeSpecifier localId="233" locator="158:60-158:90" xsi:type="ListTypeSpecifier">
               <elementType localId="232" locator="158:65-158:89" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="247" locator="162:1-163:61" name="isAllergyConfirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="247">
               <a:s>define fluent function isAllergyConfirmed(allergyIntolerance </a:s>
               <a:s r="242">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="246">
                  <a:s r="246">
                     <a:s r="244">
                        <a:s r="243">
                           <a:s>allergyIntolerance</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="244">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="245">
                        <a:s>&quot;allergy-confirmed&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="246" locator="163:3-163:61" xsi:type="Equivalent">
            <operand localId="244" locator="163:3-163:39" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="243" locator="163:3-163:20" name="allergyIntolerance" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="245" locator="163:43-163:61" name="allergy-confirmed" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="allergyIntolerance">
            <operandTypeSpecifier localId="242" locator="162:62-162:86" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="257" locator="165:1-167:52" name="allergyConfirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="257">
               <a:s>define fluent function allergyConfirmed(allergyIntolerances </a:s>
               <a:s r="249">
                  <a:s>List&lt;</a:s>
                  <a:s r="248">
                     <a:s>USCore.AllergyIntolerance</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="256">
                  <a:s r="256">
                     <a:s>
                        <a:s r="251">
                           <a:s r="250">
                              <a:s>
                                 <a:s>allergyIntolerances</a:s>
                              </a:s>
                           </a:s>
                           <a:s> A</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="255">
                        <a:s>where </a:s>
                        <a:s r="255">
                           <a:s r="253">
                              <a:s r="252">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="253">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="254">
                              <a:s>&quot;allergy-confirmed&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="256" locator="166:3-167:52" xsi:type="Query">
            <source localId="251" locator="166:3-166:23" alias="A">
               <expression localId="250" locator="166:3-166:21" name="allergyIntolerances" xsi:type="OperandRef"/>
            </source>
            <where localId="255" locator="167:5-167:52" xsi:type="Equivalent">
               <operand localId="253" locator="167:11-167:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="A" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="254" locator="167:34-167:52" name="allergy-confirmed" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="allergyIntolerances">
            <operandTypeSpecifier localId="249" locator="165:61-165:91" xsi:type="ListTypeSpecifier">
               <elementType localId="248" locator="165:66-165:90" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="263" locator="169:1-170:63" name="isAllergyUnconfirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="263">
               <a:s>define fluent function isAllergyUnconfirmed(allergyIntolerance </a:s>
               <a:s r="258">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="262">
                  <a:s r="262">
                     <a:s r="260">
                        <a:s r="259">
                           <a:s>allergyIntolerance</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="260">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="261">
                        <a:s>&quot;allergy-unconfirmed&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="262" locator="170:3-170:63" xsi:type="Equivalent">
            <operand localId="260" locator="170:3-170:39" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="259" locator="170:3-170:20" name="allergyIntolerance" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="261" locator="170:43-170:63" name="allergy-unconfirmed" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="allergyIntolerance">
            <operandTypeSpecifier localId="258" locator="169:64-169:88" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="272" locator="172:1-174:54" name="allergyUnconfirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="272">
               <a:s>define fluent function allergyUnconfirmed(allergyIntolerances </a:s>
               <a:s r="264">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="271">
                  <a:s r="271">
                     <a:s>
                        <a:s r="266">
                           <a:s r="265">
                              <a:s>
                                 <a:s>allergyIntolerances</a:s>
                              </a:s>
                           </a:s>
                           <a:s> A</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="270">
                        <a:s>where </a:s>
                        <a:s r="270">
                           <a:s r="268">
                              <a:s r="267">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="268">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="269">
                              <a:s>&quot;allergy-unconfirmed&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="271" locator="173:3-174:54" xsi:type="Query">
            <source localId="266" locator="173:3-173:23" alias="A">
               <expression localId="265" locator="173:3-173:21" name="allergyIntolerances" xsi:type="OperandRef"/>
            </source>
            <where localId="270" locator="174:5-174:54" xsi:type="Equivalent">
               <operand localId="268" locator="174:11-174:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="A" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="269" locator="174:34-174:54" name="allergy-unconfirmed" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="allergyIntolerances">
            <operandTypeSpecifier localId="264" locator="172:63-172:87" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="278" locator="176:1-177:59" name="isAllergyRefuted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="278">
               <a:s>define fluent function isAllergyRefuted(allergyIntolerance </a:s>
               <a:s r="273">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="277">
                  <a:s r="277">
                     <a:s r="275">
                        <a:s r="274">
                           <a:s>allergyIntolerance</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="275">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="276">
                        <a:s>&quot;allergy-refuted&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="277" locator="177:3-177:59" xsi:type="Equivalent">
            <operand localId="275" locator="177:3-177:39" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="274" locator="177:3-177:20" name="allergyIntolerance" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="276" locator="177:43-177:59" name="allergy-refuted" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="allergyIntolerance">
            <operandTypeSpecifier localId="273" locator="176:60-176:84" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="287" locator="179:1-181:50" name="allergyRefuted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="287">
               <a:s>define fluent function allergyRefuted(allergyIntolerances </a:s>
               <a:s r="279">
                  <a:s>USCore.AllergyIntolerance</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="286">
                  <a:s r="286">
                     <a:s>
                        <a:s r="281">
                           <a:s r="280">
                              <a:s>
                                 <a:s>allergyIntolerances</a:s>
                              </a:s>
                           </a:s>
                           <a:s> A</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="285">
                        <a:s>where </a:s>
                        <a:s r="285">
                           <a:s r="283">
                              <a:s r="282">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="283">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="284">
                              <a:s>&quot;allergy-refuted&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="286" locator="180:3-181:50" xsi:type="Query">
            <source localId="281" locator="180:3-180:23" alias="A">
               <expression localId="280" locator="180:3-180:21" name="allergyIntolerances" xsi:type="OperandRef"/>
            </source>
            <where localId="285" locator="181:5-181:50" xsi:type="Equivalent">
               <operand localId="283" locator="181:11-181:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="A" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="284" locator="181:34-181:50" name="allergy-refuted" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="allergyIntolerances">
            <operandTypeSpecifier localId="279" locator="179:59-179:83" name="fhir:AllergyIntolerance" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="297" locator="186:1-189:3" name="hasCategory" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given condition has the given category"/>
            <a:s r="297">
               <a:s>/*
@description: Returns true if the given condition has the given category
*/
define fluent function hasCategory(condition </a:s>
               <a:s r="288">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>, category </a:s>
               <a:s r="289">
                  <a:s>Code</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="296">
                  <a:s r="296">
                     <a:s>exists </a:s>
                     <a:s r="295">
                        <a:s>(</a:s>
                        <a:s r="295">
                           <a:s>
                              <a:s r="291">
                                 <a:s r="290">
                                    <a:s>
                                       <a:s>condition.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="294">
                              <a:s>where </a:s>
                              <a:s r="294">
                                 <a:s r="292">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="293">
                                    <a:s>category</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="296" locator="187:3-189:3" xsi:type="Exists">
            <operand localId="295" locator="187:10-189:3" xsi:type="Query">
               <source localId="291" locator="187:11-187:30" alias="C">
                  <expression localId="290" locator="187:11-187:28" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="condition" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="294" locator="188:5-188:22" xsi:type="Equivalent">
                  <operand localId="292" locator="188:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="293" locator="188:15-188:22" name="category" xsi:type="OperandRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="288" locator="186:46-186:61" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="category">
            <operandTypeSpecifier localId="289" locator="186:73-186:76" name="t:Code" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="306" locator="194:1-197:3" name="isProblemListItem" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given condition is a problem list item."/>
            <a:s r="306">
               <a:s>/*
@description: Returns true if the given condition is a problem list item.
*/
define fluent function isProblemListItem(condition </a:s>
               <a:s r="298">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="305">
                  <a:s r="305">
                     <a:s>exists </a:s>
                     <a:s r="304">
                        <a:s>(</a:s>
                        <a:s r="304">
                           <a:s>
                              <a:s r="300">
                                 <a:s r="299">
                                    <a:s>
                                       <a:s>condition.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="303">
                              <a:s>where </a:s>
                              <a:s r="303">
                                 <a:s r="301">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="302">
                                    <a:s>&quot;problem-list-item&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="305" locator="195:3-197:3" xsi:type="Exists">
            <operand localId="304" locator="195:10-197:3" xsi:type="Query">
               <source localId="300" locator="195:11-195:30" alias="C">
                  <expression localId="299" locator="195:11-195:28" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="condition" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="303" locator="196:5-196:33" xsi:type="Equivalent">
                  <operand localId="301" locator="196:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="302" locator="196:15-196:33" name="problem-list-item" xsi:type="CodeRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="298" locator="194:52-194:67" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="315" locator="202:1-205:3" name="isEncounterDiagnosis" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given condition is an encounter diagnosis"/>
            <a:s r="315">
               <a:s>/*
@description: Returns true if the given condition is an encounter diagnosis
*/
define fluent function isEncounterDiagnosis(condition </a:s>
               <a:s r="307">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="314">
                  <a:s r="314">
                     <a:s>exists </a:s>
                     <a:s r="313">
                        <a:s>(</a:s>
                        <a:s r="313">
                           <a:s>
                              <a:s r="309">
                                 <a:s r="308">
                                    <a:s>
                                       <a:s>condition.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="312">
                              <a:s>where </a:s>
                              <a:s r="312">
                                 <a:s r="310">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="311">
                                    <a:s>&quot;encounter-diagnosis&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="314" locator="203:3-205:3" xsi:type="Exists">
            <operand localId="313" locator="203:10-205:3" xsi:type="Query">
               <source localId="309" locator="203:11-203:30" alias="C">
                  <expression localId="308" locator="203:11-203:28" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="condition" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="312" locator="204:5-204:35" xsi:type="Equivalent">
                  <operand localId="310" locator="204:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="311" locator="204:15-204:35" name="encounter-diagnosis" xsi:type="CodeRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="307" locator="202:55-202:70" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="324" locator="210:1-213:3" name="isHealthConcern" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given condition is a health concern"/>
            <a:s r="324">
               <a:s>/*
@description: Returns true if the given condition is a health concern
*/
define fluent function isHealthConcern(condition </a:s>
               <a:s r="316">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="323">
                  <a:s r="323">
                     <a:s>exists </a:s>
                     <a:s r="322">
                        <a:s>(</a:s>
                        <a:s r="322">
                           <a:s>
                              <a:s r="318">
                                 <a:s r="317">
                                    <a:s>
                                       <a:s>condition.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="321">
                              <a:s>where </a:s>
                              <a:s r="321">
                                 <a:s r="319">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="320">
                                    <a:s>&quot;health-concern&quot;</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="323" locator="211:3-213:3" xsi:type="Exists">
            <operand localId="322" locator="211:10-213:3" xsi:type="Query">
               <source localId="318" locator="211:11-211:30" alias="C">
                  <expression localId="317" locator="211:11-211:28" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="condition" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="321" locator="212:5-212:30" xsi:type="Equivalent">
                  <operand localId="319" locator="212:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="320" locator="212:15-212:30" name="health-concern" xsi:type="CodeRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="316" locator="210:50-210:65" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="330" locator="215:1-216:46" name="isUnconfirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="330">
               <a:s>define fluent function isUnconfirmed(condition </a:s>
               <a:s r="325">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="329">
                  <a:s r="329">
                     <a:s r="327">
                        <a:s r="326">
                           <a:s>condition</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="327">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="328">
                        <a:s>&quot;unconfirmed&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="329" locator="216:3-216:46" xsi:type="Equivalent">
            <operand localId="327" locator="216:3-216:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="326" locator="216:3-216:11" name="condition" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="328" locator="216:34-216:46" name="unconfirmed" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="325" locator="215:48-215:63" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="340" locator="218:1-220:46" name="unconfirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="340">
               <a:s>define fluent function unconfirmed(conditions </a:s>
               <a:s r="332">
                  <a:s>List&lt;</a:s>
                  <a:s r="331">
                     <a:s>USCore.Condition</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="339">
                  <a:s r="339">
                     <a:s>
                        <a:s r="334">
                           <a:s r="333">
                              <a:s>
                                 <a:s>conditions</a:s>
                              </a:s>
                           </a:s>
                           <a:s> C</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="338">
                        <a:s>where </a:s>
                        <a:s r="338">
                           <a:s r="336">
                              <a:s r="335">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="336">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="337">
                              <a:s>&quot;unconfirmed&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="339" locator="219:3-220:46" xsi:type="Query">
            <source localId="334" locator="219:3-219:14" alias="C">
               <expression localId="333" locator="219:3-219:12" name="conditions" xsi:type="OperandRef"/>
            </source>
            <where localId="338" locator="220:5-220:46" xsi:type="Equivalent">
               <operand localId="336" locator="220:11-220:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="C" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="337" locator="220:34-220:46" name="unconfirmed" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="conditions">
            <operandTypeSpecifier localId="332" locator="218:47-218:68" xsi:type="ListTypeSpecifier">
               <elementType localId="331" locator="218:52-218:67" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="346" locator="222:1-223:46" name="isProvisional" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="346">
               <a:s>define fluent function isProvisional(condition </a:s>
               <a:s r="341">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="345">
                  <a:s r="345">
                     <a:s r="343">
                        <a:s r="342">
                           <a:s>condition</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="343">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="344">
                        <a:s>&quot;provisional&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="345" locator="223:3-223:46" xsi:type="Equivalent">
            <operand localId="343" locator="223:3-223:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="342" locator="223:3-223:11" name="condition" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="344" locator="223:34-223:46" name="provisional" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="341" locator="222:48-222:63" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="356" locator="225:1-227:46" name="provisional" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="356">
               <a:s>define fluent function provisional(conditions </a:s>
               <a:s r="348">
                  <a:s>List&lt;</a:s>
                  <a:s r="347">
                     <a:s>USCore.Condition</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="355">
                  <a:s r="355">
                     <a:s>
                        <a:s r="350">
                           <a:s r="349">
                              <a:s>
                                 <a:s>conditions</a:s>
                              </a:s>
                           </a:s>
                           <a:s> C</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="354">
                        <a:s>where </a:s>
                        <a:s r="354">
                           <a:s r="352">
                              <a:s r="351">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="352">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="353">
                              <a:s>&quot;provisional&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="355" locator="226:3-227:46" xsi:type="Query">
            <source localId="350" locator="226:3-226:14" alias="C">
               <expression localId="349" locator="226:3-226:12" name="conditions" xsi:type="OperandRef"/>
            </source>
            <where localId="354" locator="227:5-227:46" xsi:type="Equivalent">
               <operand localId="352" locator="227:11-227:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="C" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="353" locator="227:34-227:46" name="provisional" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="conditions">
            <operandTypeSpecifier localId="348" locator="225:47-225:68" xsi:type="ListTypeSpecifier">
               <elementType localId="347" locator="225:52-225:67" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="362" locator="229:1-230:47" name="isDifferential" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="362">
               <a:s>define fluent function isDifferential(condition </a:s>
               <a:s r="357">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="361">
                  <a:s r="361">
                     <a:s r="359">
                        <a:s r="358">
                           <a:s>condition</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="359">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="360">
                        <a:s>&quot;differential&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="361" locator="230:3-230:47" xsi:type="Equivalent">
            <operand localId="359" locator="230:3-230:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="358" locator="230:3-230:11" name="condition" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="360" locator="230:34-230:47" name="differential" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="357" locator="229:49-229:64" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="372" locator="232:1-234:47" name="differential" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="372">
               <a:s>define fluent function differential(conditions </a:s>
               <a:s r="364">
                  <a:s>List&lt;</a:s>
                  <a:s r="363">
                     <a:s>USCore.Condition</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="371">
                  <a:s r="371">
                     <a:s>
                        <a:s r="366">
                           <a:s r="365">
                              <a:s>
                                 <a:s>conditions</a:s>
                              </a:s>
                           </a:s>
                           <a:s> C</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="370">
                        <a:s>where </a:s>
                        <a:s r="370">
                           <a:s r="368">
                              <a:s r="367">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="368">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="369">
                              <a:s>&quot;differential&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="371" locator="233:3-234:47" xsi:type="Query">
            <source localId="366" locator="233:3-233:14" alias="C">
               <expression localId="365" locator="233:3-233:12" name="conditions" xsi:type="OperandRef"/>
            </source>
            <where localId="370" locator="234:5-234:47" xsi:type="Equivalent">
               <operand localId="368" locator="234:11-234:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="C" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="369" locator="234:34-234:47" name="differential" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="conditions">
            <operandTypeSpecifier localId="364" locator="232:48-232:69" xsi:type="ListTypeSpecifier">
               <elementType localId="363" locator="232:53-232:68" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="378" locator="236:1-237:44" name="isConfirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="378">
               <a:s>define fluent function isConfirmed(condition </a:s>
               <a:s r="373">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="377">
                  <a:s r="377">
                     <a:s r="375">
                        <a:s r="374">
                           <a:s>condition</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="375">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="376">
                        <a:s>&quot;confirmed&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="377" locator="237:3-237:44" xsi:type="Equivalent">
            <operand localId="375" locator="237:3-237:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="374" locator="237:3-237:11" name="condition" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="376" locator="237:34-237:44" name="confirmed" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="373" locator="236:46-236:61" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="388" locator="239:1-241:44" name="confirmed" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="388">
               <a:s>define fluent function confirmed(conditions </a:s>
               <a:s r="380">
                  <a:s>List&lt;</a:s>
                  <a:s r="379">
                     <a:s>USCore.Condition</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="387">
                  <a:s r="387">
                     <a:s>
                        <a:s r="382">
                           <a:s r="381">
                              <a:s>
                                 <a:s>conditions</a:s>
                              </a:s>
                           </a:s>
                           <a:s> C</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="386">
                        <a:s>where </a:s>
                        <a:s r="386">
                           <a:s r="384">
                              <a:s r="383">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="384">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="385">
                              <a:s>&quot;confirmed&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="387" locator="240:3-241:44" xsi:type="Query">
            <source localId="382" locator="240:3-240:14" alias="C">
               <expression localId="381" locator="240:3-240:12" name="conditions" xsi:type="OperandRef"/>
            </source>
            <where localId="386" locator="241:5-241:44" xsi:type="Equivalent">
               <operand localId="384" locator="241:11-241:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="C" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="385" locator="241:34-241:44" name="confirmed" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="conditions">
            <operandTypeSpecifier localId="380" locator="239:45-239:66" xsi:type="ListTypeSpecifier">
               <elementType localId="379" locator="239:50-239:65" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="394" locator="243:1-244:42" name="isRefuted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="394">
               <a:s>define fluent function isRefuted(condition </a:s>
               <a:s r="389">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="393">
                  <a:s r="393">
                     <a:s r="391">
                        <a:s r="390">
                           <a:s>condition</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="391">
                           <a:s>verificationStatus</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="392">
                        <a:s>&quot;refuted&quot;</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="393" locator="244:3-244:42" xsi:type="Equivalent">
            <operand localId="391" locator="244:3-244:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
               <operand path="verificationStatus" xsi:type="Property">
                  <source localId="390" locator="244:3-244:11" name="condition" xsi:type="OperandRef"/>
               </operand>
            </operand>
            <operand xsi:type="ToConcept">
               <operand localId="392" locator="244:34-244:42" name="refuted" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="389" locator="243:44-243:59" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="404" locator="246:1-248:42" name="refuted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="404">
               <a:s>define fluent function refuted(conditions </a:s>
               <a:s r="396">
                  <a:s>List&lt;</a:s>
                  <a:s r="395">
                     <a:s>USCore.Condition</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="403">
                  <a:s r="403">
                     <a:s>
                        <a:s r="398">
                           <a:s r="397">
                              <a:s>
                                 <a:s>conditions</a:s>
                              </a:s>
                           </a:s>
                           <a:s> C</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="402">
                        <a:s>where </a:s>
                        <a:s r="402">
                           <a:s r="400">
                              <a:s r="399">
                                 <a:s>C</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="400">
                                 <a:s>verificationStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="401">
                              <a:s>&quot;refuted&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="403" locator="247:3-248:42" xsi:type="Query">
            <source localId="398" locator="247:3-247:14" alias="C">
               <expression localId="397" locator="247:3-247:12" name="conditions" xsi:type="OperandRef"/>
            </source>
            <where localId="402" locator="248:5-248:42" xsi:type="Equivalent">
               <operand localId="400" locator="248:11-248:30" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="verificationStatus" scope="C" xsi:type="Property"/>
               </operand>
               <operand xsi:type="ToConcept">
                  <operand localId="401" locator="248:34-248:42" name="refuted" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="conditions">
            <operandTypeSpecifier localId="396" locator="246:43-246:64" xsi:type="ListTypeSpecifier">
               <elementType localId="395" locator="246:48-246:63" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="414" locator="253:1-256:3" name="hasCategory" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given observation has the given category"/>
            <a:s r="414">
               <a:s>/*
@description: Returns true if the given observation has the given category
*/
define fluent function hasCategory(observation </a:s>
               <a:s r="405">
                  <a:s>LaboratoryResultObservationProfile</a:s>
               </a:s>
               <a:s>, category </a:s>
               <a:s r="406">
                  <a:s>Code</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="413">
                  <a:s r="413">
                     <a:s>exists </a:s>
                     <a:s r="412">
                        <a:s>(</a:s>
                        <a:s r="412">
                           <a:s>
                              <a:s r="408">
                                 <a:s r="407">
                                    <a:s>
                                       <a:s>observation.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="411">
                              <a:s>where </a:s>
                              <a:s r="411">
                                 <a:s r="409">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="410">
                                    <a:s>category</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="413" locator="254:3-256:3" xsi:type="Exists">
            <operand localId="412" locator="254:10-256:3" xsi:type="Query">
               <source localId="408" locator="254:11-254:32" alias="C">
                  <expression localId="407" locator="254:11-254:30" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="observation" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="411" locator="255:5-255:22" xsi:type="Equivalent">
                  <operand localId="409" locator="255:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="410" locator="255:15-255:22" name="category" xsi:type="OperandRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="405" locator="253:48-253:81" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="category">
            <operandTypeSpecifier localId="406" locator="253:93-253:96" name="t:Code" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="433" locator="261:1-264:56" name="isResulted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given observation has status"/>
            <a:s r="433">
               <a:s>/*
@description: Returns true if the given observation has status
*/
define fluent function isResulted(observation </a:s>
               <a:s r="415">
                  <a:s>LaboratoryResultObservationProfile</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="432">
                  <a:s r="432">
                     <a:s r="426">
                        <a:s r="420">
                           <a:s r="417">
                              <a:s r="416">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="417">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="419">
                              <a:s r="418">
                                 <a:s>&quot;observation-final&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="419">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    or </a:s>
                        <a:s r="425">
                           <a:s r="422">
                              <a:s r="421">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="422">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="424">
                              <a:s r="423">
                                 <a:s>&quot;observation-amended&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="424">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="431">
                        <a:s r="428">
                           <a:s r="427">
                              <a:s>observation</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="428">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> ~ </a:s>
                        <a:s r="430">
                           <a:s r="429">
                              <a:s>&quot;observation-corrected&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="430">
                              <a:s>code</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="432" locator="262:3-264:56" xsi:type="Or">
            <operand localId="426" locator="262:3-263:54" xsi:type="Or">
               <operand localId="420" locator="262:3-262:47" xsi:type="Equivalent">
                  <operand localId="417" locator="262:3-262:20" path="value" xsi:type="Property">
                     <source path="status" xsi:type="Property">
                        <source localId="416" locator="262:3-262:13" name="observation" xsi:type="OperandRef"/>
                     </source>
                  </operand>
                  <operand localId="419" locator="262:24-262:47" path="code" xsi:type="Property">
                     <source localId="418" locator="262:24-262:42" name="observation-final" xsi:type="CodeRef"/>
                  </operand>
               </operand>
               <operand localId="425" locator="263:8-263:54" xsi:type="Equivalent">
                  <operand localId="422" locator="263:8-263:25" path="value" xsi:type="Property">
                     <source path="status" xsi:type="Property">
                        <source localId="421" locator="263:8-263:18" name="observation" xsi:type="OperandRef"/>
                     </source>
                  </operand>
                  <operand localId="424" locator="263:29-263:54" path="code" xsi:type="Property">
                     <source localId="423" locator="263:29-263:49" name="observation-amended" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </operand>
            <operand localId="431" locator="264:8-264:56" xsi:type="Equivalent">
               <operand localId="428" locator="264:8-264:25" path="value" xsi:type="Property">
                  <source path="status" xsi:type="Property">
                     <source localId="427" locator="264:8-264:18" name="observation" xsi:type="OperandRef"/>
                  </source>
               </operand>
               <operand localId="430" locator="264:29-264:56" path="code" xsi:type="Property">
                  <source localId="429" locator="264:29-264:51" name="observation-corrected" xsi:type="CodeRef"/>
               </operand>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="415" locator="261:47-261:80" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="456" locator="266:1-270:58" name="resulted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="456">
               <a:s>define fluent function resulted(observations </a:s>
               <a:s r="435">
                  <a:s>List&lt;</a:s>
                  <a:s r="434">
                     <a:s>LaboratoryResultObservationProfile</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="455">
                  <a:s r="455">
                     <a:s>
                        <a:s r="437">
                           <a:s r="436">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="454">
                        <a:s>where </a:s>
                        <a:s r="454">
                           <a:s r="448">
                              <a:s r="442">
                                 <a:s r="439">
                                    <a:s r="438">
                                       <a:s>observation</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="439">
                                       <a:s>status</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="441">
                                    <a:s r="440">
                                       <a:s>&quot;observation-final&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="441">
                                       <a:s>code</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
      or </a:s>
                              <a:s r="447">
                                 <a:s r="444">
                                    <a:s r="443">
                                       <a:s>observation</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="444">
                                       <a:s>status</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="446">
                                    <a:s r="445">
                                       <a:s>&quot;observation-amended&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="446">
                                       <a:s>code</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      or </a:s>
                           <a:s r="453">
                              <a:s r="450">
                                 <a:s r="449">
                                    <a:s>observation</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="450">
                                    <a:s>status</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="452">
                                 <a:s r="451">
                                    <a:s>&quot;observation-corrected&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="452">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="455" locator="267:3-270:58" xsi:type="Query">
            <source localId="437" locator="267:3-267:26" alias="observation">
               <expression localId="436" locator="267:3-267:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="454" locator="268:5-270:58" xsi:type="Or">
               <operand localId="448" locator="268:11-269:56" xsi:type="Or">
                  <operand localId="442" locator="268:11-268:55" xsi:type="Equivalent">
                     <operand localId="439" locator="268:11-268:28" path="value" xsi:type="Property">
                        <source path="status" scope="observation" xsi:type="Property"/>
                     </operand>
                     <operand localId="441" locator="268:32-268:55" path="code" xsi:type="Property">
                        <source localId="440" locator="268:32-268:50" name="observation-final" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
                  <operand localId="447" locator="269:10-269:56" xsi:type="Equivalent">
                     <operand localId="444" locator="269:10-269:27" path="value" xsi:type="Property">
                        <source path="status" scope="observation" xsi:type="Property"/>
                     </operand>
                     <operand localId="446" locator="269:31-269:56" path="code" xsi:type="Property">
                        <source localId="445" locator="269:31-269:51" name="observation-amended" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="453" locator="270:10-270:58" xsi:type="Equivalent">
                  <operand localId="450" locator="270:10-270:27" path="value" xsi:type="Property">
                     <source path="status" scope="observation" xsi:type="Property"/>
                  </operand>
                  <operand localId="452" locator="270:31-270:58" path="code" xsi:type="Property">
                     <source localId="451" locator="270:31-270:53" name="observation-corrected" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="435" locator="266:46-266:85" xsi:type="ListTypeSpecifier">
               <elementType localId="434" locator="266:51-266:84" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="463" locator="272:1-273:47" name="isFinal" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="463">
               <a:s>define fluent function isFinal(observation </a:s>
               <a:s r="457">
                  <a:s>LaboratoryResultObservationProfile</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="462">
                  <a:s r="462">
                     <a:s r="459">
                        <a:s r="458">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="459">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="461">
                        <a:s r="460">
                           <a:s>&quot;observation-final&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="461">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="462" locator="273:3-273:47" xsi:type="Equivalent">
            <operand localId="459" locator="273:3-273:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="458" locator="273:3-273:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="461" locator="273:24-273:47" path="code" xsi:type="Property">
               <source localId="460" locator="273:24-273:42" name="observation-final" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="457" locator="272:44-272:77" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="474" locator="275:1-277:55" name="final" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="474">
               <a:s>define fluent function final(observations </a:s>
               <a:s r="465">
                  <a:s>List&lt;</a:s>
                  <a:s r="464">
                     <a:s>LaboratoryResultObservationProfile</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="473">
                  <a:s r="473">
                     <a:s>
                        <a:s r="467">
                           <a:s r="466">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="472">
                        <a:s>where </a:s>
                        <a:s r="472">
                           <a:s r="469">
                              <a:s r="468">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="469">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="471">
                              <a:s r="470">
                                 <a:s>&quot;observation-final&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="471">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="473" locator="276:3-277:55" xsi:type="Query">
            <source localId="467" locator="276:3-276:26" alias="observation">
               <expression localId="466" locator="276:3-276:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="472" locator="277:5-277:55" xsi:type="Equivalent">
               <operand localId="469" locator="277:11-277:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="471" locator="277:32-277:55" path="code" xsi:type="Property">
                  <source localId="470" locator="277:32-277:50" name="observation-final" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="465" locator="275:43-275:82" xsi:type="ListTypeSpecifier">
               <elementType localId="464" locator="275:48-275:81" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="481" locator="279:1-280:49" name="isAmended" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="481">
               <a:s>define fluent function isAmended(observation </a:s>
               <a:s r="475">
                  <a:s>LaboratoryResultObservationProfile</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="480">
                  <a:s r="480">
                     <a:s r="477">
                        <a:s r="476">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="477">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="479">
                        <a:s r="478">
                           <a:s>&quot;observation-amended&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="479">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="480" locator="280:3-280:49" xsi:type="Equivalent">
            <operand localId="477" locator="280:3-280:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="476" locator="280:3-280:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="479" locator="280:24-280:49" path="code" xsi:type="Property">
               <source localId="478" locator="280:24-280:44" name="observation-amended" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="475" locator="279:46-279:79" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="492" locator="282:1-284:57" name="amended" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="492">
               <a:s>define fluent function amended(observations </a:s>
               <a:s r="483">
                  <a:s>List&lt;</a:s>
                  <a:s r="482">
                     <a:s>LaboratoryResultObservationProfile</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="491">
                  <a:s r="491">
                     <a:s>
                        <a:s r="485">
                           <a:s r="484">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="490">
                        <a:s>where </a:s>
                        <a:s r="490">
                           <a:s r="487">
                              <a:s r="486">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="487">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="489">
                              <a:s r="488">
                                 <a:s>&quot;observation-amended&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="489">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="491" locator="283:3-284:57" xsi:type="Query">
            <source localId="485" locator="283:3-283:26" alias="observation">
               <expression localId="484" locator="283:3-283:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="490" locator="284:5-284:57" xsi:type="Equivalent">
               <operand localId="487" locator="284:11-284:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="489" locator="284:32-284:57" path="code" xsi:type="Property">
                  <source localId="488" locator="284:32-284:52" name="observation-amended" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="483" locator="282:45-282:84" xsi:type="ListTypeSpecifier">
               <elementType localId="482" locator="282:50-282:83" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="499" locator="286:1-287:51" name="isCorrected" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="499">
               <a:s>define fluent function isCorrected(observation </a:s>
               <a:s r="493">
                  <a:s>LaboratoryResultObservationProfile</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="498">
                  <a:s r="498">
                     <a:s r="495">
                        <a:s r="494">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="495">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="497">
                        <a:s r="496">
                           <a:s>&quot;observation-corrected&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="497">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="498" locator="287:3-287:51" xsi:type="Equivalent">
            <operand localId="495" locator="287:3-287:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="494" locator="287:3-287:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="497" locator="287:24-287:51" path="code" xsi:type="Property">
               <source localId="496" locator="287:24-287:46" name="observation-corrected" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="493" locator="286:48-286:81" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="510" locator="289:1-291:59" name="corrected" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="510">
               <a:s>define fluent function corrected(observations </a:s>
               <a:s r="501">
                  <a:s>List&lt;</a:s>
                  <a:s r="500">
                     <a:s>LaboratoryResultObservationProfile</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="509">
                  <a:s r="509">
                     <a:s>
                        <a:s r="503">
                           <a:s r="502">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="508">
                        <a:s>where </a:s>
                        <a:s r="508">
                           <a:s r="505">
                              <a:s r="504">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="505">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="507">
                              <a:s r="506">
                                 <a:s>&quot;observation-corrected&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="507">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="509" locator="290:3-291:59" xsi:type="Query">
            <source localId="503" locator="290:3-290:26" alias="observation">
               <expression localId="502" locator="290:3-290:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="508" locator="291:5-291:59" xsi:type="Equivalent">
               <operand localId="505" locator="291:11-291:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="507" locator="291:32-291:59" path="code" xsi:type="Property">
                  <source localId="506" locator="291:32-291:54" name="observation-corrected" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="501" locator="289:47-289:86" xsi:type="ListTypeSpecifier">
               <elementType localId="500" locator="289:52-289:85" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="529" locator="294:1-297:56" name="isResulted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="529">
               <a:s>define fluent function isResulted(observation </a:s>
               <a:s r="511">
                  <a:s>&quot;observation-bodyweight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="528">
                  <a:s r="528">
                     <a:s r="522">
                        <a:s r="516">
                           <a:s r="513">
                              <a:s r="512">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="513">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="515">
                              <a:s r="514">
                                 <a:s>&quot;observation-final&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="515">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    or </a:s>
                        <a:s r="521">
                           <a:s r="518">
                              <a:s r="517">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="518">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="520">
                              <a:s r="519">
                                 <a:s>&quot;observation-amended&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="520">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="527">
                        <a:s r="524">
                           <a:s r="523">
                              <a:s>observation</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="524">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> ~ </a:s>
                        <a:s r="526">
                           <a:s r="525">
                              <a:s>&quot;observation-corrected&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="526">
                              <a:s>code</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="528" locator="295:3-297:56" xsi:type="Or">
            <operand localId="522" locator="295:3-296:54" xsi:type="Or">
               <operand localId="516" locator="295:3-295:47" xsi:type="Equivalent">
                  <operand localId="513" locator="295:3-295:20" path="value" xsi:type="Property">
                     <source path="status" xsi:type="Property">
                        <source localId="512" locator="295:3-295:13" name="observation" xsi:type="OperandRef"/>
                     </source>
                  </operand>
                  <operand localId="515" locator="295:24-295:47" path="code" xsi:type="Property">
                     <source localId="514" locator="295:24-295:42" name="observation-final" xsi:type="CodeRef"/>
                  </operand>
               </operand>
               <operand localId="521" locator="296:8-296:54" xsi:type="Equivalent">
                  <operand localId="518" locator="296:8-296:25" path="value" xsi:type="Property">
                     <source path="status" xsi:type="Property">
                        <source localId="517" locator="296:8-296:18" name="observation" xsi:type="OperandRef"/>
                     </source>
                  </operand>
                  <operand localId="520" locator="296:29-296:54" path="code" xsi:type="Property">
                     <source localId="519" locator="296:29-296:49" name="observation-amended" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </operand>
            <operand localId="527" locator="297:8-297:56" xsi:type="Equivalent">
               <operand localId="524" locator="297:8-297:25" path="value" xsi:type="Property">
                  <source path="status" xsi:type="Property">
                     <source localId="523" locator="297:8-297:18" name="observation" xsi:type="OperandRef"/>
                  </source>
               </operand>
               <operand localId="526" locator="297:29-297:56" path="code" xsi:type="Property">
                  <source localId="525" locator="297:29-297:51" name="observation-corrected" xsi:type="CodeRef"/>
               </operand>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="511" locator="294:47-294:70" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="552" locator="299:1-303:58" name="resulted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="552">
               <a:s>define fluent function resulted(observations </a:s>
               <a:s r="531">
                  <a:s>List&lt;</a:s>
                  <a:s r="530">
                     <a:s>&quot;observation-bodyweight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="551">
                  <a:s r="551">
                     <a:s>
                        <a:s r="533">
                           <a:s r="532">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="550">
                        <a:s>where </a:s>
                        <a:s r="550">
                           <a:s r="544">
                              <a:s r="538">
                                 <a:s r="535">
                                    <a:s r="534">
                                       <a:s>observation</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="535">
                                       <a:s>status</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="537">
                                    <a:s r="536">
                                       <a:s>&quot;observation-final&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="537">
                                       <a:s>code</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
      or </a:s>
                              <a:s r="543">
                                 <a:s r="540">
                                    <a:s r="539">
                                       <a:s>observation</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="540">
                                       <a:s>status</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="542">
                                    <a:s r="541">
                                       <a:s>&quot;observation-amended&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="542">
                                       <a:s>code</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      or </a:s>
                           <a:s r="549">
                              <a:s r="546">
                                 <a:s r="545">
                                    <a:s>observation</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="546">
                                    <a:s>status</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="548">
                                 <a:s r="547">
                                    <a:s>&quot;observation-corrected&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="548">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="551" locator="300:3-303:58" xsi:type="Query">
            <source localId="533" locator="300:3-300:26" alias="observation">
               <expression localId="532" locator="300:3-300:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="550" locator="301:5-303:58" xsi:type="Or">
               <operand localId="544" locator="301:11-302:56" xsi:type="Or">
                  <operand localId="538" locator="301:11-301:55" xsi:type="Equivalent">
                     <operand localId="535" locator="301:11-301:28" path="value" xsi:type="Property">
                        <source path="status" scope="observation" xsi:type="Property"/>
                     </operand>
                     <operand localId="537" locator="301:32-301:55" path="code" xsi:type="Property">
                        <source localId="536" locator="301:32-301:50" name="observation-final" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
                  <operand localId="543" locator="302:10-302:56" xsi:type="Equivalent">
                     <operand localId="540" locator="302:10-302:27" path="value" xsi:type="Property">
                        <source path="status" scope="observation" xsi:type="Property"/>
                     </operand>
                     <operand localId="542" locator="302:31-302:56" path="code" xsi:type="Property">
                        <source localId="541" locator="302:31-302:51" name="observation-amended" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="549" locator="303:10-303:58" xsi:type="Equivalent">
                  <operand localId="546" locator="303:10-303:27" path="value" xsi:type="Property">
                     <source path="status" scope="observation" xsi:type="Property"/>
                  </operand>
                  <operand localId="548" locator="303:31-303:58" path="code" xsi:type="Property">
                     <source localId="547" locator="303:31-303:53" name="observation-corrected" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="531" locator="299:46-299:75" xsi:type="ListTypeSpecifier">
               <elementType localId="530" locator="299:51-299:74" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="559" locator="305:1-306:47" name="isFinal" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="559">
               <a:s>define fluent function isFinal(observation </a:s>
               <a:s r="553">
                  <a:s>&quot;observation-bodyweight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="558">
                  <a:s r="558">
                     <a:s r="555">
                        <a:s r="554">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="555">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="557">
                        <a:s r="556">
                           <a:s>&quot;observation-final&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="557">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="558" locator="306:3-306:47" xsi:type="Equivalent">
            <operand localId="555" locator="306:3-306:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="554" locator="306:3-306:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="557" locator="306:24-306:47" path="code" xsi:type="Property">
               <source localId="556" locator="306:24-306:42" name="observation-final" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="553" locator="305:44-305:67" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="570" locator="308:1-310:55" name="final" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="570">
               <a:s>define fluent function final(observations </a:s>
               <a:s r="561">
                  <a:s>List&lt;</a:s>
                  <a:s r="560">
                     <a:s>&quot;observation-bodyweight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="569">
                  <a:s r="569">
                     <a:s>
                        <a:s r="563">
                           <a:s r="562">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="568">
                        <a:s>where </a:s>
                        <a:s r="568">
                           <a:s r="565">
                              <a:s r="564">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="565">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="567">
                              <a:s r="566">
                                 <a:s>&quot;observation-final&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="567">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="569" locator="309:3-310:55" xsi:type="Query">
            <source localId="563" locator="309:3-309:26" alias="observation">
               <expression localId="562" locator="309:3-309:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="568" locator="310:5-310:55" xsi:type="Equivalent">
               <operand localId="565" locator="310:11-310:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="567" locator="310:32-310:55" path="code" xsi:type="Property">
                  <source localId="566" locator="310:32-310:50" name="observation-final" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="561" locator="308:43-308:72" xsi:type="ListTypeSpecifier">
               <elementType localId="560" locator="308:48-308:71" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="577" locator="312:1-313:49" name="isAmended" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="577">
               <a:s>define fluent function isAmended(observation </a:s>
               <a:s r="571">
                  <a:s>&quot;observation-bodyweight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="576">
                  <a:s r="576">
                     <a:s r="573">
                        <a:s r="572">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="573">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="575">
                        <a:s r="574">
                           <a:s>&quot;observation-amended&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="575">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="576" locator="313:3-313:49" xsi:type="Equivalent">
            <operand localId="573" locator="313:3-313:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="572" locator="313:3-313:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="575" locator="313:24-313:49" path="code" xsi:type="Property">
               <source localId="574" locator="313:24-313:44" name="observation-amended" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="571" locator="312:46-312:69" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="588" locator="315:1-317:57" name="amended" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="588">
               <a:s>define fluent function amended(observations </a:s>
               <a:s r="579">
                  <a:s>List&lt;</a:s>
                  <a:s r="578">
                     <a:s>&quot;observation-bodyweight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="587">
                  <a:s r="587">
                     <a:s>
                        <a:s r="581">
                           <a:s r="580">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="586">
                        <a:s>where </a:s>
                        <a:s r="586">
                           <a:s r="583">
                              <a:s r="582">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="583">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="585">
                              <a:s r="584">
                                 <a:s>&quot;observation-amended&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="585">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="587" locator="316:3-317:57" xsi:type="Query">
            <source localId="581" locator="316:3-316:26" alias="observation">
               <expression localId="580" locator="316:3-316:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="586" locator="317:5-317:57" xsi:type="Equivalent">
               <operand localId="583" locator="317:11-317:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="585" locator="317:32-317:57" path="code" xsi:type="Property">
                  <source localId="584" locator="317:32-317:52" name="observation-amended" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="579" locator="315:45-315:74" xsi:type="ListTypeSpecifier">
               <elementType localId="578" locator="315:50-315:73" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="595" locator="319:1-320:51" name="isCorrected" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="595">
               <a:s>define fluent function isCorrected(observation </a:s>
               <a:s r="589">
                  <a:s>&quot;observation-bodyweight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="594">
                  <a:s r="594">
                     <a:s r="591">
                        <a:s r="590">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="591">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="593">
                        <a:s r="592">
                           <a:s>&quot;observation-corrected&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="593">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="594" locator="320:3-320:51" xsi:type="Equivalent">
            <operand localId="591" locator="320:3-320:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="590" locator="320:3-320:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="593" locator="320:24-320:51" path="code" xsi:type="Property">
               <source localId="592" locator="320:24-320:46" name="observation-corrected" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="589" locator="319:48-319:71" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="606" locator="322:1-324:59" name="corrected" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="606">
               <a:s>define fluent function corrected(observations </a:s>
               <a:s r="597">
                  <a:s>List&lt;</a:s>
                  <a:s r="596">
                     <a:s>&quot;observation-bodyweight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="605">
                  <a:s r="605">
                     <a:s>
                        <a:s r="599">
                           <a:s r="598">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="604">
                        <a:s>where </a:s>
                        <a:s r="604">
                           <a:s r="601">
                              <a:s r="600">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="601">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="603">
                              <a:s r="602">
                                 <a:s>&quot;observation-corrected&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="603">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="605" locator="323:3-324:59" xsi:type="Query">
            <source localId="599" locator="323:3-323:26" alias="observation">
               <expression localId="598" locator="323:3-323:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="604" locator="324:5-324:59" xsi:type="Equivalent">
               <operand localId="601" locator="324:11-324:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="603" locator="324:32-324:59" path="code" xsi:type="Property">
                  <source localId="602" locator="324:32-324:54" name="observation-corrected" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="597" locator="322:47-322:76" xsi:type="ListTypeSpecifier">
               <elementType localId="596" locator="322:52-322:75" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="625" locator="327:1-330:56" name="isResulted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="625">
               <a:s>define fluent function isResulted(observation </a:s>
               <a:s r="607">
                  <a:s>&quot;observation-bodyheight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="624">
                  <a:s r="624">
                     <a:s r="618">
                        <a:s r="612">
                           <a:s r="609">
                              <a:s r="608">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="609">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="611">
                              <a:s r="610">
                                 <a:s>&quot;observation-final&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="611">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
    or </a:s>
                        <a:s r="617">
                           <a:s r="614">
                              <a:s r="613">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="614">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="616">
                              <a:s r="615">
                                 <a:s>&quot;observation-amended&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="616">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    or </a:s>
                     <a:s r="623">
                        <a:s r="620">
                           <a:s r="619">
                              <a:s>observation</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="620">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> ~ </a:s>
                        <a:s r="622">
                           <a:s r="621">
                              <a:s>&quot;observation-corrected&quot;</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="622">
                              <a:s>code</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="624" locator="328:3-330:56" xsi:type="Or">
            <operand localId="618" locator="328:3-329:54" xsi:type="Or">
               <operand localId="612" locator="328:3-328:47" xsi:type="Equivalent">
                  <operand localId="609" locator="328:3-328:20" path="value" xsi:type="Property">
                     <source path="status" xsi:type="Property">
                        <source localId="608" locator="328:3-328:13" name="observation" xsi:type="OperandRef"/>
                     </source>
                  </operand>
                  <operand localId="611" locator="328:24-328:47" path="code" xsi:type="Property">
                     <source localId="610" locator="328:24-328:42" name="observation-final" xsi:type="CodeRef"/>
                  </operand>
               </operand>
               <operand localId="617" locator="329:8-329:54" xsi:type="Equivalent">
                  <operand localId="614" locator="329:8-329:25" path="value" xsi:type="Property">
                     <source path="status" xsi:type="Property">
                        <source localId="613" locator="329:8-329:18" name="observation" xsi:type="OperandRef"/>
                     </source>
                  </operand>
                  <operand localId="616" locator="329:29-329:54" path="code" xsi:type="Property">
                     <source localId="615" locator="329:29-329:49" name="observation-amended" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </operand>
            <operand localId="623" locator="330:8-330:56" xsi:type="Equivalent">
               <operand localId="620" locator="330:8-330:25" path="value" xsi:type="Property">
                  <source path="status" xsi:type="Property">
                     <source localId="619" locator="330:8-330:18" name="observation" xsi:type="OperandRef"/>
                  </source>
               </operand>
               <operand localId="622" locator="330:29-330:56" path="code" xsi:type="Property">
                  <source localId="621" locator="330:29-330:51" name="observation-corrected" xsi:type="CodeRef"/>
               </operand>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="607" locator="327:47-327:70" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="648" locator="332:1-336:58" name="resulted" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="648">
               <a:s>define fluent function resulted(observations </a:s>
               <a:s r="627">
                  <a:s>List&lt;</a:s>
                  <a:s r="626">
                     <a:s>&quot;observation-bodyheight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="647">
                  <a:s r="647">
                     <a:s>
                        <a:s r="629">
                           <a:s r="628">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="646">
                        <a:s>where </a:s>
                        <a:s r="646">
                           <a:s r="640">
                              <a:s r="634">
                                 <a:s r="631">
                                    <a:s r="630">
                                       <a:s>observation</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="631">
                                       <a:s>status</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="633">
                                    <a:s r="632">
                                       <a:s>&quot;observation-final&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="633">
                                       <a:s>code</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
      or </a:s>
                              <a:s r="639">
                                 <a:s r="636">
                                    <a:s r="635">
                                       <a:s>observation</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="636">
                                       <a:s>status</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="638">
                                    <a:s r="637">
                                       <a:s>&quot;observation-amended&quot;</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="638">
                                       <a:s>code</a:s>
                                    </a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      or </a:s>
                           <a:s r="645">
                              <a:s r="642">
                                 <a:s r="641">
                                    <a:s>observation</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="642">
                                    <a:s>status</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="644">
                                 <a:s r="643">
                                    <a:s>&quot;observation-corrected&quot;</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="644">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="647" locator="333:3-336:58" xsi:type="Query">
            <source localId="629" locator="333:3-333:26" alias="observation">
               <expression localId="628" locator="333:3-333:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="646" locator="334:5-336:58" xsi:type="Or">
               <operand localId="640" locator="334:11-335:56" xsi:type="Or">
                  <operand localId="634" locator="334:11-334:55" xsi:type="Equivalent">
                     <operand localId="631" locator="334:11-334:28" path="value" xsi:type="Property">
                        <source path="status" scope="observation" xsi:type="Property"/>
                     </operand>
                     <operand localId="633" locator="334:32-334:55" path="code" xsi:type="Property">
                        <source localId="632" locator="334:32-334:50" name="observation-final" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
                  <operand localId="639" locator="335:10-335:56" xsi:type="Equivalent">
                     <operand localId="636" locator="335:10-335:27" path="value" xsi:type="Property">
                        <source path="status" scope="observation" xsi:type="Property"/>
                     </operand>
                     <operand localId="638" locator="335:31-335:56" path="code" xsi:type="Property">
                        <source localId="637" locator="335:31-335:51" name="observation-amended" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="645" locator="336:10-336:58" xsi:type="Equivalent">
                  <operand localId="642" locator="336:10-336:27" path="value" xsi:type="Property">
                     <source path="status" scope="observation" xsi:type="Property"/>
                  </operand>
                  <operand localId="644" locator="336:31-336:58" path="code" xsi:type="Property">
                     <source localId="643" locator="336:31-336:53" name="observation-corrected" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="627" locator="332:46-332:75" xsi:type="ListTypeSpecifier">
               <elementType localId="626" locator="332:51-332:74" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="655" locator="338:1-339:47" name="isFinal" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="655">
               <a:s>define fluent function isFinal(observation </a:s>
               <a:s r="649">
                  <a:s>&quot;observation-bodyheight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="654">
                  <a:s r="654">
                     <a:s r="651">
                        <a:s r="650">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="651">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="653">
                        <a:s r="652">
                           <a:s>&quot;observation-final&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="653">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="654" locator="339:3-339:47" xsi:type="Equivalent">
            <operand localId="651" locator="339:3-339:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="650" locator="339:3-339:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="653" locator="339:24-339:47" path="code" xsi:type="Property">
               <source localId="652" locator="339:24-339:42" name="observation-final" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="649" locator="338:44-338:67" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="666" locator="341:1-343:55" name="final" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="666">
               <a:s>define fluent function final(observations </a:s>
               <a:s r="657">
                  <a:s>List&lt;</a:s>
                  <a:s r="656">
                     <a:s>&quot;observation-bodyheight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="665">
                  <a:s r="665">
                     <a:s>
                        <a:s r="659">
                           <a:s r="658">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="664">
                        <a:s>where </a:s>
                        <a:s r="664">
                           <a:s r="661">
                              <a:s r="660">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="661">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="663">
                              <a:s r="662">
                                 <a:s>&quot;observation-final&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="663">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="665" locator="342:3-343:55" xsi:type="Query">
            <source localId="659" locator="342:3-342:26" alias="observation">
               <expression localId="658" locator="342:3-342:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="664" locator="343:5-343:55" xsi:type="Equivalent">
               <operand localId="661" locator="343:11-343:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="663" locator="343:32-343:55" path="code" xsi:type="Property">
                  <source localId="662" locator="343:32-343:50" name="observation-final" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="657" locator="341:43-341:72" xsi:type="ListTypeSpecifier">
               <elementType localId="656" locator="341:48-341:71" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="673" locator="345:1-346:49" name="isAmended" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="673">
               <a:s>define fluent function isAmended(observation </a:s>
               <a:s r="667">
                  <a:s>&quot;observation-bodyheight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="672">
                  <a:s r="672">
                     <a:s r="669">
                        <a:s r="668">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="669">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="671">
                        <a:s r="670">
                           <a:s>&quot;observation-amended&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="671">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="672" locator="346:3-346:49" xsi:type="Equivalent">
            <operand localId="669" locator="346:3-346:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="668" locator="346:3-346:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="671" locator="346:24-346:49" path="code" xsi:type="Property">
               <source localId="670" locator="346:24-346:44" name="observation-amended" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="667" locator="345:46-345:69" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="684" locator="348:1-350:57" name="amended" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="684">
               <a:s>define fluent function amended(observations </a:s>
               <a:s r="675">
                  <a:s>List&lt;</a:s>
                  <a:s r="674">
                     <a:s>&quot;observation-bodyheight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="683">
                  <a:s r="683">
                     <a:s>
                        <a:s r="677">
                           <a:s r="676">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="682">
                        <a:s>where </a:s>
                        <a:s r="682">
                           <a:s r="679">
                              <a:s r="678">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="679">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="681">
                              <a:s r="680">
                                 <a:s>&quot;observation-amended&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="681">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="683" locator="349:3-350:57" xsi:type="Query">
            <source localId="677" locator="349:3-349:26" alias="observation">
               <expression localId="676" locator="349:3-349:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="682" locator="350:5-350:57" xsi:type="Equivalent">
               <operand localId="679" locator="350:11-350:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="681" locator="350:32-350:57" path="code" xsi:type="Property">
                  <source localId="680" locator="350:32-350:52" name="observation-amended" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="675" locator="348:45-348:74" xsi:type="ListTypeSpecifier">
               <elementType localId="674" locator="348:50-348:73" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="691" locator="352:1-353:51" name="isCorrected" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="691">
               <a:s>define fluent function isCorrected(observation </a:s>
               <a:s r="685">
                  <a:s>&quot;observation-bodyheight&quot;</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="690">
                  <a:s r="690">
                     <a:s r="687">
                        <a:s r="686">
                           <a:s>observation</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="687">
                           <a:s>status</a:s>
                        </a:s>
                     </a:s>
                     <a:s> ~ </a:s>
                     <a:s r="689">
                        <a:s r="688">
                           <a:s>&quot;observation-corrected&quot;</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="689">
                           <a:s>code</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="690" locator="353:3-353:51" xsi:type="Equivalent">
            <operand localId="687" locator="353:3-353:20" path="value" xsi:type="Property">
               <source path="status" xsi:type="Property">
                  <source localId="686" locator="353:3-353:13" name="observation" xsi:type="OperandRef"/>
               </source>
            </operand>
            <operand localId="689" locator="353:24-353:51" path="code" xsi:type="Property">
               <source localId="688" locator="353:24-353:46" name="observation-corrected" xsi:type="CodeRef"/>
            </operand>
         </expression>
         <operand name="observation">
            <operandTypeSpecifier localId="685" locator="352:48-352:71" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="705" locator="355:1-358:29" name="corrected" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="705">
               <a:s>define fluent function corrected(observations </a:s>
               <a:s r="693">
                  <a:s>List&lt;</a:s>
                  <a:s r="692">
                     <a:s>&quot;observation-bodyheight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="704">
                  <a:s r="704">
                     <a:s>
                        <a:s r="695">
                           <a:s r="694">
                              <a:s>
                                 <a:s>observations</a:s>
                              </a:s>
                           </a:s>
                           <a:s> observation</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="700">
                        <a:s>where </a:s>
                        <a:s r="700">
                           <a:s r="697">
                              <a:s r="696">
                                 <a:s>observation</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="697">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="699">
                              <a:s r="698">
                                 <a:s>&quot;observation-corrected&quot;</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="699">
                                 <a:s>code</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="703">
                        <a:s>return </a:s>
                        <a:s r="702">
                           <a:s r="701">
                              <a:s>observation</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="702">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="704" locator="356:3-358:29" xsi:type="Query">
            <source localId="695" locator="356:3-356:26" alias="observation">
               <expression localId="694" locator="356:3-356:14" name="observations" xsi:type="OperandRef"/>
            </source>
            <where localId="700" locator="357:5-357:59" xsi:type="Equivalent">
               <operand localId="697" locator="357:11-357:28" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </operand>
               <operand localId="699" locator="357:32-357:59" path="code" xsi:type="Property">
                  <source localId="698" locator="357:32-357:54" name="observation-corrected" xsi:type="CodeRef"/>
               </operand>
            </where>
            <return localId="703" locator="358:5-358:29">
               <expression localId="702" locator="358:12-358:29" path="value" xsi:type="Property">
                  <source path="status" scope="observation" xsi:type="Property"/>
               </expression>
            </return>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="693" locator="355:47-355:76" xsi:type="ListTypeSpecifier">
               <elementType localId="692" locator="355:52-355:75" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="714" locator="363:1-366:3" name="isCommunity" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given MedicationRequest has a category of Community"/>
            <a:s r="714">
               <a:s>/*
@description: Returns true if the given MedicationRequest has a category of Community
*/
define fluent function isCommunity(medicationRequest </a:s>
               <a:s r="706">
                  <a:s>MedicationRequestProfile</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="713">
                  <a:s r="713">
                     <a:s>exists </a:s>
                     <a:s r="712">
                        <a:s>(</a:s>
                        <a:s r="712">
                           <a:s>
                              <a:s r="708">
                                 <a:s r="707">
                                    <a:s>
                                       <a:s>medicationRequest.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="711">
                              <a:s>where </a:s>
                              <a:s r="711">
                                 <a:s r="709">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="710">
                                    <a:s>Community</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="713" locator="364:3-366:3" xsi:type="Exists">
            <operand localId="712" locator="364:10-366:3" xsi:type="Query">
               <source localId="708" locator="364:11-364:38" alias="C">
                  <expression localId="707" locator="364:11-364:36" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="medicationRequest" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="711" locator="365:5-365:23" xsi:type="Equivalent">
                  <operand localId="709" locator="365:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="710" locator="365:15-365:23" name="Community" xsi:type="CodeRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="medicationRequest">
            <operandTypeSpecifier localId="706" locator="363:54-363:77" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="723" locator="371:1-374:3" name="isDischarge" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given MedicationRequest has a category of Discharge"/>
            <a:s r="723">
               <a:s>/*
@description: Returns true if the given MedicationRequest has a category of Discharge
*/
define fluent function isDischarge(medicationRequest </a:s>
               <a:s r="715">
                  <a:s>MedicationRequestProfile</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="722">
                  <a:s r="722">
                     <a:s>exists </a:s>
                     <a:s r="721">
                        <a:s>(</a:s>
                        <a:s r="721">
                           <a:s>
                              <a:s r="717">
                                 <a:s r="716">
                                    <a:s>
                                       <a:s>medicationRequest.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="720">
                              <a:s>where </a:s>
                              <a:s r="720">
                                 <a:s r="718">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="719">
                                    <a:s>Discharge</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="722" locator="372:3-374:3" xsi:type="Exists">
            <operand localId="721" locator="372:10-374:3" xsi:type="Query">
               <source localId="717" locator="372:11-372:38" alias="C">
                  <expression localId="716" locator="372:11-372:36" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="medicationRequest" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="720" locator="373:5-373:23" xsi:type="Equivalent">
                  <operand localId="718" locator="373:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="719" locator="373:15-373:23" name="Discharge" xsi:type="CodeRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="medicationRequest">
            <operandTypeSpecifier localId="715" locator="371:54-371:77" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="733" locator="379:1-382:3" name="hasCategory" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns true if the given MedicationRequest has the given category"/>
            <a:s r="733">
               <a:s>/*
@description: Returns true if the given MedicationRequest has the given category
*/
define fluent function hasCategory(medicationRequest </a:s>
               <a:s r="724">
                  <a:s>MedicationRequestProfile</a:s>
               </a:s>
               <a:s>, category </a:s>
               <a:s r="725">
                  <a:s>Code</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="732">
                  <a:s r="732">
                     <a:s>exists </a:s>
                     <a:s r="731">
                        <a:s>(</a:s>
                        <a:s r="731">
                           <a:s>
                              <a:s r="727">
                                 <a:s r="726">
                                    <a:s>
                                       <a:s>medicationRequest.category</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> C</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
    </a:s>
                           <a:s r="730">
                              <a:s>where </a:s>
                              <a:s r="730">
                                 <a:s r="728">
                                    <a:s>C</a:s>
                                 </a:s>
                                 <a:s> ~ </a:s>
                                 <a:s r="729">
                                    <a:s>category</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="732" locator="380:3-382:3" xsi:type="Exists">
            <operand localId="731" locator="380:10-382:3" xsi:type="Query">
               <source localId="727" locator="380:11-380:38" alias="C">
                  <expression localId="726" locator="380:11-380:36" xsi:type="Query">
                     <source alias="$this">
                        <expression path="category" xsi:type="Property">
                           <source name="medicationRequest" xsi:type="OperandRef"/>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </expression>
               </source>
               <where localId="730" locator="381:5-381:22" xsi:type="Equivalent">
                  <operand localId="728" locator="381:11" name="C" xsi:type="AliasRef"/>
                  <operand xsi:type="ToConcept">
                     <operand localId="729" locator="381:15-381:22" name="category" xsi:type="OperandRef"/>
                  </operand>
               </where>
            </operand>
         </expression>
         <operand name="medicationRequest">
            <operandTypeSpecifier localId="724" locator="379:54-379:77" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
         </operand>
         <operand name="category">
            <operandTypeSpecifier localId="725" locator="379:89-379:92" name="t:Code" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="807" locator="404:1-418:4" name="toInterval" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Normalizes a value that is a choice of timing-valued types to an equivalent interval"/>
            <a:t name="comment" value="Normalizes a choice type of DateTime, Quanitty, Interval&lt;DateTime>, or Interval&lt;Quantity> types&#xa;to an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible&#xa;representations for timing-valued elements in QICore, allowing this function to be used across any resource.&#xa;The input can be provided as a DateTime, Quantity, Interval&lt;DateTime> or Interval&lt;Quantity>.&#xa;The intent of this function is to provide a clear and concise mechanism to treat single&#xa;elements that have multiple possible representations as intervals so that logic doesn't have to account&#xa;for the variability. More complex calculations (such as medication request period or dispense period&#xa;calculation) need specific guidance and consideration. That guidance may make use of this function, but&#xa;the focus of this function is on single element calculations where the semantics are unambiguous.&#xa;If the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.&#xa;If the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,&#xa;and the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.&#xa;If the input is a DateTime Interval, the result is the input.&#xa;If the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result&#xa;is a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending&#xa;immediately before one year later than the date the patient turned the age given as the end of the quantity interval.&#xa;Any other input will reslt in a null DateTime Interval"/>
            <a:s r="807">
               <a:s>/*
@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval
@comment: Normalizes a choice type of DateTime, Quanitty, Interval&lt;DateTime>, or Interval&lt;Quantity> types
to an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible
representations for timing-valued elements in QICore, allowing this function to be used across any resource.
The input can be provided as a DateTime, Quantity, Interval&lt;DateTime> or Interval&lt;Quantity>.
The intent of this function is to provide a clear and concise mechanism to treat single
elements that have multiple possible representations as intervals so that logic doesn't have to account
for the variability. More complex calculations (such as medication request period or dispense period
calculation) need specific guidance and consideration. That guidance may make use of this function, but
the focus of this function is on single element calculations where the semantics are unambiguous.
If the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.
If the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,
and the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.
If the input is a DateTime Interval, the result is the input.
If the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result
is a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending
immediately before one year later than the date the patient turned the age given as the end of the quantity interval.
Any other input will reslt in a null DateTime Interval
*/
define fluent function toInterval(choice </a:s>
               <a:s r="740">
                  <a:s>Choice&lt;</a:s>
                  <a:s r="734">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="735">
                     <a:s>Quantity</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="737">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="736">
                        <a:s>DateTime</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="739">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="738">
                        <a:s>Quantity</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="806">
                  <a:s r="806">
                     <a:s>case
	  </a:s>
                     <a:s r="751">
                        <a:s>when </a:s>
                        <a:s r="743">
                           <a:s r="741">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="742">
                              <a:s>DateTime</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then
    	</a:s>
                        <a:s r="750">
                           <a:s>Interval[</a:s>
                           <a:s r="746">
                              <a:s r="744">
                                 <a:s>choice</a:s>
                              </a:s>
                              <a:s> as </a:s>
                              <a:s r="745">
                                 <a:s>DateTime</a:s>
                              </a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="749">
                              <a:s r="747">
                                 <a:s>choice</a:s>
                              </a:s>
                              <a:s> as </a:s>
                              <a:s r="748">
                                 <a:s>DateTime</a:s>
                              </a:s>
                           </a:s>
                           <a:s>]</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
		</a:s>
                     <a:s r="760">
                        <a:s>when </a:s>
                        <a:s r="755">
                           <a:s r="752">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="754">
                              <a:s>Interval&lt;</a:s>
                              <a:s r="753">
                                 <a:s>DateTime</a:s>
                              </a:s>
                              <a:s>></a:s>
                           </a:s>
                        </a:s>
                        <a:s> then
  		</a:s>
                        <a:s r="759">
                           <a:s r="756">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> as </a:s>
                           <a:s r="758">
                              <a:s>Interval&lt;</a:s>
                              <a:s r="757">
                                 <a:s>DateTime</a:s>
                              </a:s>
                              <a:s>></a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
		</a:s>
                     <a:s r="779">
                        <a:s>when </a:s>
                        <a:s r="763">
                           <a:s r="761">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="762">
                              <a:s>Quantity</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then
		  </a:s>
                        <a:s r="778">
                           <a:s>Interval[</a:s>
                           <a:s r="769">
                              <a:s r="765">
                                 <a:s r="764">
                                    <a:s>Patient</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="765">
                                    <a:s>birthDate</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="768">
                                 <a:s>(</a:s>
                                 <a:s r="768">
                                    <a:s r="766">
                                       <a:s>choice</a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="767">
                                       <a:s>Quantity</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s>,
			  </a:s>
                           <a:s r="777">
                              <a:s r="775">
                                 <a:s r="771">
                                    <a:s r="770">
                                       <a:s>Patient</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="771">
                                       <a:s>birthDate</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="774">
                                    <a:s>(</a:s>
                                    <a:s r="774">
                                       <a:s r="772">
                                          <a:s>choice</a:s>
                                       </a:s>
                                       <a:s> as </a:s>
                                       <a:s r="773">
                                          <a:s>Quantity</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="776">
                                 <a:s>1 year</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
		</a:s>
                     <a:s r="801">
                        <a:s>when </a:s>
                        <a:s r="783">
                           <a:s r="780">
                              <a:s>choice</a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="782">
                              <a:s>Interval&lt;</a:s>
                              <a:s r="781">
                                 <a:s>Quantity</a:s>
                              </a:s>
                              <a:s>></a:s>
                           </a:s>
                        </a:s>
                        <a:s> then
		  </a:s>
                        <a:s r="800">
                           <a:s>Interval[</a:s>
                           <a:s r="790">
                              <a:s r="785">
                                 <a:s r="784">
                                    <a:s>Patient</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="785">
                                    <a:s>birthDate</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="789">
                                 <a:s>(</a:s>
                                 <a:s r="789">
                                    <a:s r="787">
                                       <a:s r="786">
                                          <a:s>choice</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="787">
                                          <a:s>low</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="788">
                                       <a:s>Quantity</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s>,
			  </a:s>
                           <a:s r="799">
                              <a:s r="797">
                                 <a:s r="792">
                                    <a:s r="791">
                                       <a:s>Patient</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="792">
                                       <a:s>birthDate</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="796">
                                    <a:s>(</a:s>
                                    <a:s r="796">
                                       <a:s r="794">
                                          <a:s r="793">
                                             <a:s>choice</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="794">
                                             <a:s>high</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> as </a:s>
                                       <a:s r="795">
                                          <a:s>Quantity</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="798">
                                 <a:s>1 year</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
		else
			</a:s>
                     <a:s r="805">
                        <a:s r="802">null as </a:s>
                        <a:s r="804">
                           <a:s>Interval&lt;</a:s>
                           <a:s r="803">
                              <a:s>DateTime</a:s>
                           </a:s>
                           <a:s>></a:s>
                        </a:s>
                     </a:s>
                     <a:s>
	end</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="806" locator="405:3-418:4" xsi:type="Case">
            <caseItem localId="751" locator="406:4-407:53">
               <when localId="743" locator="406:9-406:26" xsi:type="Is">
                  <operand localId="741" locator="406:9-406:14" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="742" locator="406:19-406:26" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then localId="750" locator="407:6-407:53" lowClosed="true" highClosed="true" xsi:type="Interval">
                  <low localId="746" locator="407:15-407:32" strict="false" xsi:type="As">
                     <operand localId="744" locator="407:15-407:20" name="choice" xsi:type="OperandRef"/>
                     <asTypeSpecifier localId="745" locator="407:25-407:32" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                  </low>
                  <high localId="749" locator="407:35-407:52" strict="false" xsi:type="As">
                     <operand localId="747" locator="407:35-407:40" name="choice" xsi:type="OperandRef"/>
                     <asTypeSpecifier localId="748" locator="407:45-407:52" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                  </high>
               </then>
            </caseItem>
            <caseItem localId="760" locator="408:3-409:32">
               <when localId="755" locator="408:8-408:35" xsi:type="Is">
                  <operand localId="752" locator="408:8-408:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="754" locator="408:18-408:35" xsi:type="IntervalTypeSpecifier">
                     <pointType localId="753" locator="408:27-408:34" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                  </isTypeSpecifier>
               </when>
               <then localId="759" locator="409:5-409:32" strict="false" xsi:type="As">
                  <operand localId="756" locator="409:5-409:10" name="choice" xsi:type="OperandRef"/>
                  <asTypeSpecifier localId="758" locator="409:15-409:32" xsi:type="IntervalTypeSpecifier">
                     <pointType localId="757" locator="409:24-409:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                  </asTypeSpecifier>
               </then>
            </caseItem>
            <caseItem localId="779" locator="410:3-412:55">
               <when localId="763" locator="410:8-410:25" xsi:type="Is">
                  <operand localId="761" locator="410:8-410:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="762" locator="410:18-410:25" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
               </when>
               <then xsi:type="Interval">
                  <low xsi:type="ToDateTime">
                     <operand path="low" xsi:type="Property">
                        <source localId="778" locator="411:5-412:55" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="769" locator="411:14-411:53" xsi:type="Add">
                              <operand localId="765" locator="411:14-411:30" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="764" locator="411:14-411:20" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="768" locator="411:34-411:53" strict="false" xsi:type="As">
                                    <operand localId="766" locator="411:35-411:40" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="767" locator="411:45-411:52" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="777" locator="412:6-412:54" xsi:type="Add">
                              <operand localId="775" locator="412:6-412:45" xsi:type="Add">
                                 <operand localId="771" locator="412:6-412:22" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="770" locator="412:6-412:12" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="774" locator="412:26-412:45" strict="false" xsi:type="As">
                                       <operand localId="772" locator="412:27-412:32" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="773" locator="412:37-412:44" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="776" locator="412:49-412:54" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </low>
                  <lowClosedExpression path="lowClosed" xsi:type="Property">
                     <source localId="778" locator="411:5-412:55" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="769" locator="411:14-411:53" xsi:type="Add">
                           <operand localId="765" locator="411:14-411:30" path="value" xsi:type="Property">
                              <source path="birthDate" xsi:type="Property">
                                 <source localId="764" locator="411:14-411:20" name="Patient" xsi:type="ExpressionRef"/>
                              </source>
                           </operand>
                           <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="768" locator="411:34-411:53" strict="false" xsi:type="As">
                                 <operand localId="766" locator="411:35-411:40" name="choice" xsi:type="OperandRef"/>
                                 <asTypeSpecifier localId="767" locator="411:45-411:52" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </operand>
                           </operand>
                        </low>
                        <high localId="777" locator="412:6-412:54" xsi:type="Add">
                           <operand localId="775" locator="412:6-412:45" xsi:type="Add">
                              <operand localId="771" locator="412:6-412:22" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="770" locator="412:6-412:12" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="774" locator="412:26-412:45" strict="false" xsi:type="As">
                                    <operand localId="772" locator="412:27-412:32" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="773" locator="412:37-412:44" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="776" locator="412:49-412:54" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </lowClosedExpression>
                  <high xsi:type="ToDateTime">
                     <operand path="high" xsi:type="Property">
                        <source localId="778" locator="411:5-412:55" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="769" locator="411:14-411:53" xsi:type="Add">
                              <operand localId="765" locator="411:14-411:30" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="764" locator="411:14-411:20" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="768" locator="411:34-411:53" strict="false" xsi:type="As">
                                    <operand localId="766" locator="411:35-411:40" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="767" locator="411:45-411:52" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="777" locator="412:6-412:54" xsi:type="Add">
                              <operand localId="775" locator="412:6-412:45" xsi:type="Add">
                                 <operand localId="771" locator="412:6-412:22" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="770" locator="412:6-412:12" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="774" locator="412:26-412:45" strict="false" xsi:type="As">
                                       <operand localId="772" locator="412:27-412:32" name="choice" xsi:type="OperandRef"/>
                                       <asTypeSpecifier localId="773" locator="412:37-412:44" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="776" locator="412:49-412:54" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </high>
                  <highClosedExpression path="highClosed" xsi:type="Property">
                     <source localId="778" locator="411:5-412:55" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="769" locator="411:14-411:53" xsi:type="Add">
                           <operand localId="765" locator="411:14-411:30" path="value" xsi:type="Property">
                              <source path="birthDate" xsi:type="Property">
                                 <source localId="764" locator="411:14-411:20" name="Patient" xsi:type="ExpressionRef"/>
                              </source>
                           </operand>
                           <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="768" locator="411:34-411:53" strict="false" xsi:type="As">
                                 <operand localId="766" locator="411:35-411:40" name="choice" xsi:type="OperandRef"/>
                                 <asTypeSpecifier localId="767" locator="411:45-411:52" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </operand>
                           </operand>
                        </low>
                        <high localId="777" locator="412:6-412:54" xsi:type="Add">
                           <operand localId="775" locator="412:6-412:45" xsi:type="Add">
                              <operand localId="771" locator="412:6-412:22" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="770" locator="412:6-412:12" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="774" locator="412:26-412:45" strict="false" xsi:type="As">
                                    <operand localId="772" locator="412:27-412:32" name="choice" xsi:type="OperandRef"/>
                                    <asTypeSpecifier localId="773" locator="412:37-412:44" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="776" locator="412:49-412:54" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </highClosedExpression>
               </then>
            </caseItem>
            <caseItem localId="801" locator="413:3-415:60">
               <when localId="783" locator="413:8-413:35" xsi:type="Is">
                  <operand localId="780" locator="413:8-413:13" name="choice" xsi:type="OperandRef"/>
                  <isTypeSpecifier localId="782" locator="413:18-413:35" xsi:type="IntervalTypeSpecifier">
                     <pointType localId="781" locator="413:27-413:34" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                  </isTypeSpecifier>
               </when>
               <then xsi:type="Interval">
                  <low xsi:type="ToDateTime">
                     <operand path="low" xsi:type="Property">
                        <source localId="800" locator="414:5-415:60" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="790" locator="414:14-414:57" xsi:type="Add">
                              <operand localId="785" locator="414:14-414:30" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="784" locator="414:14-414:20" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="789" locator="414:34-414:57" strict="false" xsi:type="As">
                                    <operand localId="787" locator="414:35-414:44" path="low" xsi:type="Property">
                                       <source localId="786" locator="414:35-414:40" name="choice" xsi:type="OperandRef"/>
                                    </operand>
                                    <asTypeSpecifier localId="788" locator="414:49-414:56" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="799" locator="415:6-415:59" xsi:type="Add">
                              <operand localId="797" locator="415:6-415:50" xsi:type="Add">
                                 <operand localId="792" locator="415:6-415:22" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="791" locator="415:6-415:12" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="796" locator="415:26-415:50" strict="false" xsi:type="As">
                                       <operand localId="794" locator="415:27-415:37" path="high" xsi:type="Property">
                                          <source localId="793" locator="415:27-415:32" name="choice" xsi:type="OperandRef"/>
                                       </operand>
                                       <asTypeSpecifier localId="795" locator="415:42-415:49" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="798" locator="415:54-415:59" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </low>
                  <lowClosedExpression path="lowClosed" xsi:type="Property">
                     <source localId="800" locator="414:5-415:60" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="790" locator="414:14-414:57" xsi:type="Add">
                           <operand localId="785" locator="414:14-414:30" path="value" xsi:type="Property">
                              <source path="birthDate" xsi:type="Property">
                                 <source localId="784" locator="414:14-414:20" name="Patient" xsi:type="ExpressionRef"/>
                              </source>
                           </operand>
                           <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="789" locator="414:34-414:57" strict="false" xsi:type="As">
                                 <operand localId="787" locator="414:35-414:44" path="low" xsi:type="Property">
                                    <source localId="786" locator="414:35-414:40" name="choice" xsi:type="OperandRef"/>
                                 </operand>
                                 <asTypeSpecifier localId="788" locator="414:49-414:56" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </operand>
                           </operand>
                        </low>
                        <high localId="799" locator="415:6-415:59" xsi:type="Add">
                           <operand localId="797" locator="415:6-415:50" xsi:type="Add">
                              <operand localId="792" locator="415:6-415:22" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="791" locator="415:6-415:12" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="796" locator="415:26-415:50" strict="false" xsi:type="As">
                                    <operand localId="794" locator="415:27-415:37" path="high" xsi:type="Property">
                                       <source localId="793" locator="415:27-415:32" name="choice" xsi:type="OperandRef"/>
                                    </operand>
                                    <asTypeSpecifier localId="795" locator="415:42-415:49" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="798" locator="415:54-415:59" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </lowClosedExpression>
                  <high xsi:type="ToDateTime">
                     <operand path="high" xsi:type="Property">
                        <source localId="800" locator="414:5-415:60" lowClosed="true" highClosed="false" xsi:type="Interval">
                           <low localId="790" locator="414:14-414:57" xsi:type="Add">
                              <operand localId="785" locator="414:14-414:30" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="784" locator="414:14-414:20" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="789" locator="414:34-414:57" strict="false" xsi:type="As">
                                    <operand localId="787" locator="414:35-414:44" path="low" xsi:type="Property">
                                       <source localId="786" locator="414:35-414:40" name="choice" xsi:type="OperandRef"/>
                                    </operand>
                                    <asTypeSpecifier localId="788" locator="414:49-414:56" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </low>
                           <high localId="799" locator="415:6-415:59" xsi:type="Add">
                              <operand localId="797" locator="415:6-415:50" xsi:type="Add">
                                 <operand localId="792" locator="415:6-415:22" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="791" locator="415:6-415:12" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand localId="796" locator="415:26-415:50" strict="false" xsi:type="As">
                                       <operand localId="794" locator="415:27-415:37" path="high" xsi:type="Property">
                                          <source localId="793" locator="415:27-415:32" name="choice" xsi:type="OperandRef"/>
                                       </operand>
                                       <asTypeSpecifier localId="795" locator="415:42-415:49" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <operand localId="798" locator="415:54-415:59" value="1" unit="year" xsi:type="Quantity"/>
                           </high>
                        </source>
                     </operand>
                  </high>
                  <highClosedExpression path="highClosed" xsi:type="Property">
                     <source localId="800" locator="414:5-415:60" lowClosed="true" highClosed="false" xsi:type="Interval">
                        <low localId="790" locator="414:14-414:57" xsi:type="Add">
                           <operand localId="785" locator="414:14-414:30" path="value" xsi:type="Property">
                              <source path="birthDate" xsi:type="Property">
                                 <source localId="784" locator="414:14-414:20" name="Patient" xsi:type="ExpressionRef"/>
                              </source>
                           </operand>
                           <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand localId="789" locator="414:34-414:57" strict="false" xsi:type="As">
                                 <operand localId="787" locator="414:35-414:44" path="low" xsi:type="Property">
                                    <source localId="786" locator="414:35-414:40" name="choice" xsi:type="OperandRef"/>
                                 </operand>
                                 <asTypeSpecifier localId="788" locator="414:49-414:56" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </operand>
                           </operand>
                        </low>
                        <high localId="799" locator="415:6-415:59" xsi:type="Add">
                           <operand localId="797" locator="415:6-415:50" xsi:type="Add">
                              <operand localId="792" locator="415:6-415:22" path="value" xsi:type="Property">
                                 <source path="birthDate" xsi:type="Property">
                                    <source localId="791" locator="415:6-415:12" name="Patient" xsi:type="ExpressionRef"/>
                                 </source>
                              </operand>
                              <operand name="ToQuantity" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand localId="796" locator="415:26-415:50" strict="false" xsi:type="As">
                                    <operand localId="794" locator="415:27-415:37" path="high" xsi:type="Property">
                                       <source localId="793" locator="415:27-415:32" name="choice" xsi:type="OperandRef"/>
                                    </operand>
                                    <asTypeSpecifier localId="795" locator="415:42-415:49" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </operand>
                           </operand>
                           <operand localId="798" locator="415:54-415:59" value="1" unit="year" xsi:type="Quantity"/>
                        </high>
                     </source>
                  </highClosedExpression>
               </then>
            </caseItem>
            <else localId="805" locator="417:4-417:29" strict="false" xsi:type="As">
               <operand localId="802" locator="417:4-417:7" xsi:type="Null"/>
               <asTypeSpecifier localId="804" locator="417:12-417:29" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="803" locator="417:21-417:28" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </asTypeSpecifier>
            </else>
         </expression>
         <operand name="choice">
            <operandTypeSpecifier localId="740" locator="404:42-404:107" xsi:type="ChoiceTypeSpecifier">
               <choice localId="734" locator="404:49-404:56" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               <choice localId="735" locator="404:59-404:66" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
               <choice localId="737" locator="404:69-404:86" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="736" locator="404:78-404:85" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </choice>
               <choice localId="739" locator="404:89-404:106" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="738" locator="404:98-404:105" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
               </choice>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="887" locator="430:1-441:32" name="abatementInterval" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns an interval representing the normalized abatement of a given Condition."/>
            <a:t name="comment" value="If the abatement element of the Condition is represented as a DateTime, the result&#xa;is an interval beginning and ending on that DateTime.&#xa;If the abatement is represented as a Quantity, the quantity is expected to be a calendar-duration and is interpreted as the age of the patient. The&#xa;result is an interval from the date the patient turned that age to immediately before one year later.&#xa;If the abatement is represented as a Quantity Interval, the quantities are expected to be calendar-durations and are interpreted as an age range during&#xa;which the abatement occurred. The result is an interval from the date the patient turned the starting age of the quantity interval, and ending immediately&#xa;before one year later than the date the patient turned the ending age of the quantity interval."/>
            <a:s r="887">
               <a:s>/*
@description: Returns an interval representing the normalized abatement of a given Condition.
@comment: If the abatement element of the Condition is represented as a DateTime, the result
is an interval beginning and ending on that DateTime.
If the abatement is represented as a Quantity, the quantity is expected to be a calendar-duration and is interpreted as the age of the patient. The
result is an interval from the date the patient turned that age to immediately before one year later.
If the abatement is represented as a Quantity Interval, the quantities are expected to be calendar-durations and are interpreted as an age range during
which the abatement occurred. The result is an interval from the date the patient turned the starting age of the quantity interval, and ending immediately
before one year later than the date the patient turned the ending age of the quantity interval.
*/
define fluent function abatementInterval(condition </a:s>
               <a:s r="808">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
	</a:s>
               <a:s r="886">
                  <a:s r="886">
                     <a:s>if </a:s>
                     <a:s r="812">
                        <a:s r="810">
                           <a:s r="809">
                              <a:s>condition</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="810">
                              <a:s>abatement</a:s>
                           </a:s>
                        </a:s>
                        <a:s> is </a:s>
                        <a:s r="811">
                           <a:s>DateTime</a:s>
                        </a:s>
                     </a:s>
                     <a:s> then
	  </a:s>
                     <a:s r="821">
                        <a:s>Interval[</a:s>
                        <a:s r="816">
                           <a:s r="814">
                              <a:s r="813">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="814">
                                 <a:s>abatement</a:s>
                              </a:s>
                           </a:s>
                           <a:s> as </a:s>
                           <a:s r="815">
                              <a:s>DateTime</a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="820">
                           <a:s r="818">
                              <a:s r="817">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="818">
                                 <a:s>abatement</a:s>
                              </a:s>
                           </a:s>
                           <a:s> as </a:s>
                           <a:s r="819">
                              <a:s>DateTime</a:s>
                           </a:s>
                        </a:s>
                        <a:s>]</a:s>
                     </a:s>
                     <a:s>
	else </a:s>
                     <a:s r="885">
                        <a:s>if </a:s>
                        <a:s r="825">
                           <a:s r="823">
                              <a:s r="822">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="823">
                                 <a:s>abatement</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is </a:s>
                           <a:s r="824">
                              <a:s>System.Quantity</a:s>
                           </a:s>
                        </a:s>
                        <a:s> then
		</a:s>
                        <a:s r="842">
                           <a:s>Interval[</a:s>
                           <a:s r="832">
                              <a:s r="827">
                                 <a:s r="826">
                                    <a:s>Patient</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="827">
                                    <a:s>birthDate</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="831">
                                 <a:s>(</a:s>
                                 <a:s r="831">
                                    <a:s r="829">
                                       <a:s r="828">
                                          <a:s>condition</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="829">
                                          <a:s>abatement</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="830">
                                       <a:s>System.Quantity</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s>,
			</a:s>
                           <a:s r="841">
                              <a:s r="839">
                                 <a:s r="834">
                                    <a:s r="833">
                                       <a:s>Patient</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="834">
                                       <a:s>birthDate</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="838">
                                    <a:s>(</a:s>
                                    <a:s r="838">
                                       <a:s r="836">
                                          <a:s r="835">
                                             <a:s>condition</a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="836">
                                             <a:s>abatement</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> as </a:s>
                                       <a:s r="837">
                                          <a:s>System.Quantity</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> + </a:s>
                              <a:s r="840">
                                 <a:s>1 year</a:s>
                              </a:s>
                           </a:s>
                           <a:s>)</a:s>
                        </a:s>
                        <a:s>
	else </a:s>
                        <a:s r="884">
                           <a:s>if </a:s>
                           <a:s r="847">
                              <a:s r="844">
                                 <a:s r="843">
                                    <a:s>condition</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="844">
                                    <a:s>abatement</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> is </a:s>
                              <a:s r="846">
                                 <a:s>Interval&lt;</a:s>
                                 <a:s r="845">
                                    <a:s>System.Quantity</a:s>
                                 </a:s>
                                 <a:s>></a:s>
                              </a:s>
                           </a:s>
                           <a:s> then
	  </a:s>
                           <a:s r="866">
                              <a:s>Interval[</a:s>
                              <a:s r="855">
                                 <a:s r="849">
                                    <a:s r="848">
                                       <a:s>Patient</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="849">
                                       <a:s>birthDate</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="854">
                                    <a:s>(</a:s>
                                    <a:s r="854">
                                       <a:s r="852">
                                          <a:s r="851">
                                             <a:s r="850">
                                                <a:s>condition</a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="851">
                                                <a:s>abatement</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s>.</a:s>
                                          <a:s r="852">
                                             <a:s>low</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s> as </a:s>
                                       <a:s r="853">
                                          <a:s>System.Quantity</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>)</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>,
		  </a:s>
                              <a:s r="865">
                                 <a:s r="863">
                                    <a:s r="857">
                                       <a:s r="856">
                                          <a:s>Patient</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="857">
                                          <a:s>birthDate</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> + </a:s>
                                    <a:s r="862">
                                       <a:s>(</a:s>
                                       <a:s r="862">
                                          <a:s r="860">
                                             <a:s r="859">
                                                <a:s r="858">
                                                   <a:s>condition</a:s>
                                                </a:s>
                                                <a:s>.</a:s>
                                                <a:s r="859">
                                                   <a:s>abatement</a:s>
                                                </a:s>
                                             </a:s>
                                             <a:s>.</a:s>
                                             <a:s r="860">
                                                <a:s>high</a:s>
                                             </a:s>
                                          </a:s>
                                          <a:s> as </a:s>
                                          <a:s r="861">
                                             <a:s>System.Quantity</a:s>
                                          </a:s>
                                       </a:s>
                                       <a:s>)</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> + </a:s>
                                 <a:s r="864">
                                    <a:s>1 year</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s>
	else </a:s>
                           <a:s r="883">
                              <a:s>if </a:s>
                              <a:s r="871">
                                 <a:s r="868">
                                    <a:s r="867">
                                       <a:s>condition</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="868">
                                       <a:s>abatement</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> is </a:s>
                                 <a:s r="870">
                                    <a:s>Interval&lt;</a:s>
                                    <a:s r="869">
                                       <a:s>DateTime</a:s>
                                    </a:s>
                                    <a:s>></a:s>
                                 </a:s>
                              </a:s>
                              <a:s> then
	  </a:s>
                              <a:s r="878">
                                 <a:s>Interval[</a:s>
                                 <a:s r="874">
                                    <a:s r="873">
                                       <a:s r="872">
                                          <a:s>condition</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="873">
                                          <a:s>abatement</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="874">
                                       <a:s>low</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>, </a:s>
                                 <a:s r="877">
                                    <a:s r="876">
                                       <a:s r="875">
                                          <a:s>condition</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="876">
                                          <a:s>abatement</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="877">
                                       <a:s>high</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                              <a:s>
	else </a:s>
                              <a:s r="882">
                                 <a:s r="879">null as </a:s>
                                 <a:s r="881">
                                    <a:s>Interval&lt;</a:s>
                                    <a:s r="880">
                                       <a:s>DateTime</a:s>
                                    </a:s>
                                    <a:s>></a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="886" locator="431:2-441:32" xsi:type="If">
            <condition localId="812" locator="431:5-431:35" xsi:type="Is">
               <operand localId="810" locator="431:5-431:23" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="abatement" xsi:type="Property">
                     <source localId="809" locator="431:5-431:13" name="condition" xsi:type="OperandRef"/>
                  </operand>
               </operand>
               <isTypeSpecifier localId="811" locator="431:28-431:35" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
            </condition>
            <then localId="821" locator="432:4-432:77" lowClosed="true" highClosed="true" xsi:type="Interval">
               <low localId="816" locator="432:13-432:43" strict="false" xsi:type="As">
                  <operand localId="814" locator="432:13-432:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="abatement" xsi:type="Property">
                        <source localId="813" locator="432:13-432:21" name="condition" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
                  <asTypeSpecifier localId="815" locator="432:36-432:43" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </low>
               <high localId="820" locator="432:46-432:76" strict="false" xsi:type="As">
                  <operand localId="818" locator="432:46-432:64" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="abatement" xsi:type="Property">
                        <source localId="817" locator="432:46-432:54" name="condition" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
                  <asTypeSpecifier localId="819" locator="432:69-432:76" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </high>
            </then>
            <else xsi:type="Interval">
               <low asType="t:DateTime" xsi:type="As">
                  <operand path="low" xsi:type="Property">
                     <source localId="885" locator="433:7-441:32" xsi:type="If">
                        <condition localId="825" locator="433:10-433:47" xsi:type="Is">
                           <operand localId="823" locator="433:10-433:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand path="abatement" xsi:type="Property">
                                 <source localId="822" locator="433:10-433:18" name="condition" xsi:type="OperandRef"/>
                              </operand>
                           </operand>
                           <isTypeSpecifier localId="824" locator="433:33-433:47" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        </condition>
                        <then xsi:type="Interval">
                           <low xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="low" xsi:type="Property">
                                    <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                          <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                             <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                          <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                             <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                                <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </operand>
                                                <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </low>
                           <lowClosedExpression path="lowClosed" xsi:type="Property">
                              <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                    <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                       <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                    <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                       <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                          <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </lowClosedExpression>
                           <high xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="high" xsi:type="Property">
                                    <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                          <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                             <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                          <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                             <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                                <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </operand>
                                                <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </high>
                           <highClosedExpression path="highClosed" xsi:type="Property">
                              <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                    <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                       <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                    <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                       <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                          <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </highClosedExpression>
                        </then>
                        <else localId="884" locator="436:7-441:32" xsi:type="If">
                           <condition localId="847" locator="436:10-436:57" xsi:type="Is">
                              <operand localId="844" locator="436:10-436:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="abatement" xsi:type="Property">
                                    <source localId="843" locator="436:10-436:18" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                              <isTypeSpecifier localId="846" locator="436:33-436:57" xsi:type="IntervalTypeSpecifier">
                                 <pointType localId="845" locator="436:42-436:56" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </condition>
                           <then xsi:type="Interval">
                              <low xsi:type="ToDateTime">
                                 <operand asType="t:Date" xsi:type="As">
                                    <operand path="low" xsi:type="Property">
                                       <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                          <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                             <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                                <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                   <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </low>
                                          <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                             <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                                <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                   <source path="birthDate" xsi:type="Property">
                                                      <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                   </source>
                                                </operand>
                                                <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                   <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                      <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                         <operand path="abatement" xsi:type="Property">
                                                            <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                         </operand>
                                                      </source>
                                                   </operand>
                                                   <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                                </operand>
                                             </operand>
                                             <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                          </high>
                                       </source>
                                    </operand>
                                 </operand>
                              </low>
                              <lowClosedExpression path="lowClosed" xsi:type="Property">
                                 <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                       <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                          <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                             <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                       <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                          <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                             <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </lowClosedExpression>
                              <high xsi:type="ToDateTime">
                                 <operand asType="t:Date" xsi:type="As">
                                    <operand path="high" xsi:type="Property">
                                       <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                          <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                             <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                                <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                   <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </low>
                                          <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                             <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                                <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                   <source path="birthDate" xsi:type="Property">
                                                      <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                   </source>
                                                </operand>
                                                <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                   <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                      <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                         <operand path="abatement" xsi:type="Property">
                                                            <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                         </operand>
                                                      </source>
                                                   </operand>
                                                   <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                                </operand>
                                             </operand>
                                             <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                          </high>
                                       </source>
                                    </operand>
                                 </operand>
                              </high>
                              <highClosedExpression path="highClosed" xsi:type="Property">
                                 <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                       <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                          <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                             <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                       <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                          <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                             <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </highClosedExpression>
                           </then>
                           <else localId="883" locator="439:7-441:32" xsi:type="If">
                              <condition localId="871" locator="439:10-439:50" xsi:type="Is">
                                 <operand localId="868" locator="439:10-439:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="abatement" xsi:type="Property">
                                       <source localId="867" locator="439:10-439:18" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                                 <isTypeSpecifier localId="870" locator="439:33-439:50" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="869" locator="439:42-439:49" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </isTypeSpecifier>
                              </condition>
                              <then localId="878" locator="440:4-440:62" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="874" locator="440:13-440:35" path="low" xsi:type="Property">
                                    <source localId="873" locator="440:13-440:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="872" locator="440:13-440:21" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </source>
                                 </low>
                                 <high localId="877" locator="440:38-440:61" path="high" xsi:type="Property">
                                    <source localId="876" locator="440:38-440:56" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="875" locator="440:38-440:46" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </source>
                                 </high>
                              </then>
                              <else xsi:type="Interval">
                                 <low xsi:type="As">
                                    <operand path="low" xsi:type="Property">
                                       <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                          <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                          <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </asTypeSpecifier>
                                       </source>
                                    </operand>
                                    <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                       <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </low>
                                 <lowClosedExpression path="lowClosed" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </lowClosedExpression>
                                 <high xsi:type="As">
                                    <operand path="high" xsi:type="Property">
                                       <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                          <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                          <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </asTypeSpecifier>
                                       </source>
                                    </operand>
                                    <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                       <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </high>
                                 <highClosedExpression path="highClosed" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </highClosedExpression>
                              </else>
                           </else>
                        </else>
                     </source>
                  </operand>
               </low>
               <lowClosedExpression path="lowClosed" xsi:type="Property">
                  <source localId="885" locator="433:7-441:32" xsi:type="If">
                     <condition localId="825" locator="433:10-433:47" xsi:type="Is">
                        <operand localId="823" locator="433:10-433:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand path="abatement" xsi:type="Property">
                              <source localId="822" locator="433:10-433:18" name="condition" xsi:type="OperandRef"/>
                           </operand>
                        </operand>
                        <isTypeSpecifier localId="824" locator="433:33-433:47" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                     </condition>
                     <then xsi:type="Interval">
                        <low xsi:type="ToDateTime">
                           <operand asType="t:Date" xsi:type="As">
                              <operand path="low" xsi:type="Property">
                                 <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                       <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                          <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                       <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                          <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                             <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </operand>
                           </operand>
                        </low>
                        <lowClosedExpression path="lowClosed" xsi:type="Property">
                           <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                 <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                    <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </operand>
                                    <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </low>
                              <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                 <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                    <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                       <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                                 <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                              </high>
                           </source>
                        </lowClosedExpression>
                        <high xsi:type="ToDateTime">
                           <operand asType="t:Date" xsi:type="As">
                              <operand path="high" xsi:type="Property">
                                 <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                       <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                          <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                       <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                          <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                             <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </operand>
                           </operand>
                        </high>
                        <highClosedExpression path="highClosed" xsi:type="Property">
                           <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                 <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                    <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </operand>
                                    <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </low>
                              <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                 <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                    <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                       <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                                 <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                              </high>
                           </source>
                        </highClosedExpression>
                     </then>
                     <else localId="884" locator="436:7-441:32" xsi:type="If">
                        <condition localId="847" locator="436:10-436:57" xsi:type="Is">
                           <operand localId="844" locator="436:10-436:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand path="abatement" xsi:type="Property">
                                 <source localId="843" locator="436:10-436:18" name="condition" xsi:type="OperandRef"/>
                              </operand>
                           </operand>
                           <isTypeSpecifier localId="846" locator="436:33-436:57" xsi:type="IntervalTypeSpecifier">
                              <pointType localId="845" locator="436:42-436:56" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                           </isTypeSpecifier>
                        </condition>
                        <then xsi:type="Interval">
                           <low xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="low" xsi:type="Property">
                                    <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                          <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                             <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                          <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                             <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                   <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </low>
                           <lowClosedExpression path="lowClosed" xsi:type="Property">
                              <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                    <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                       <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                          <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </source>
                                       </operand>
                                       <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                    <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                       <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                          <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                             <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </lowClosedExpression>
                           <high xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="high" xsi:type="Property">
                                    <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                          <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                             <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                          <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                             <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                   <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </high>
                           <highClosedExpression path="highClosed" xsi:type="Property">
                              <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                    <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                       <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                          <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </source>
                                       </operand>
                                       <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                    <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                       <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                          <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                             <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </highClosedExpression>
                        </then>
                        <else localId="883" locator="439:7-441:32" xsi:type="If">
                           <condition localId="871" locator="439:10-439:50" xsi:type="Is">
                              <operand localId="868" locator="439:10-439:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="abatement" xsi:type="Property">
                                    <source localId="867" locator="439:10-439:18" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                              <isTypeSpecifier localId="870" locator="439:33-439:50" xsi:type="IntervalTypeSpecifier">
                                 <pointType localId="869" locator="439:42-439:49" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </condition>
                           <then localId="878" locator="440:4-440:62" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="874" locator="440:13-440:35" path="low" xsi:type="Property">
                                 <source localId="873" locator="440:13-440:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="abatement" xsi:type="Property">
                                       <source localId="872" locator="440:13-440:21" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </source>
                              </low>
                              <high localId="877" locator="440:38-440:61" path="high" xsi:type="Property">
                                 <source localId="876" locator="440:38-440:56" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="abatement" xsi:type="Property">
                                       <source localId="875" locator="440:38-440:46" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </source>
                              </high>
                           </then>
                           <else xsi:type="Interval">
                              <low xsi:type="As">
                                 <operand path="low" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </operand>
                                 <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                    <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </low>
                              <lowClosedExpression path="lowClosed" xsi:type="Property">
                                 <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                    <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                    <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </source>
                              </lowClosedExpression>
                              <high xsi:type="As">
                                 <operand path="high" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </operand>
                                 <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                    <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </high>
                              <highClosedExpression path="highClosed" xsi:type="Property">
                                 <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                    <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                    <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </source>
                              </highClosedExpression>
                           </else>
                        </else>
                     </else>
                  </source>
               </lowClosedExpression>
               <high asType="t:DateTime" xsi:type="As">
                  <operand path="high" xsi:type="Property">
                     <source localId="885" locator="433:7-441:32" xsi:type="If">
                        <condition localId="825" locator="433:10-433:47" xsi:type="Is">
                           <operand localId="823" locator="433:10-433:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand path="abatement" xsi:type="Property">
                                 <source localId="822" locator="433:10-433:18" name="condition" xsi:type="OperandRef"/>
                              </operand>
                           </operand>
                           <isTypeSpecifier localId="824" locator="433:33-433:47" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                        </condition>
                        <then xsi:type="Interval">
                           <low xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="low" xsi:type="Property">
                                    <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                          <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                             <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                          <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                             <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                                <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </operand>
                                                <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </low>
                           <lowClosedExpression path="lowClosed" xsi:type="Property">
                              <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                    <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                       <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                    <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                       <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                          <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </lowClosedExpression>
                           <high xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="high" xsi:type="Property">
                                    <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                          <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                             <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                          <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                             <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                                <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </operand>
                                                <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </high>
                           <highClosedExpression path="highClosed" xsi:type="Property">
                              <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                    <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                       <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                    <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                       <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                          <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </highClosedExpression>
                        </then>
                        <else localId="884" locator="436:7-441:32" xsi:type="If">
                           <condition localId="847" locator="436:10-436:57" xsi:type="Is">
                              <operand localId="844" locator="436:10-436:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="abatement" xsi:type="Property">
                                    <source localId="843" locator="436:10-436:18" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                              <isTypeSpecifier localId="846" locator="436:33-436:57" xsi:type="IntervalTypeSpecifier">
                                 <pointType localId="845" locator="436:42-436:56" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </condition>
                           <then xsi:type="Interval">
                              <low xsi:type="ToDateTime">
                                 <operand asType="t:Date" xsi:type="As">
                                    <operand path="low" xsi:type="Property">
                                       <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                          <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                             <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                                <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                   <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </low>
                                          <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                             <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                                <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                   <source path="birthDate" xsi:type="Property">
                                                      <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                   </source>
                                                </operand>
                                                <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                   <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                      <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                         <operand path="abatement" xsi:type="Property">
                                                            <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                         </operand>
                                                      </source>
                                                   </operand>
                                                   <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                                </operand>
                                             </operand>
                                             <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                          </high>
                                       </source>
                                    </operand>
                                 </operand>
                              </low>
                              <lowClosedExpression path="lowClosed" xsi:type="Property">
                                 <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                       <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                          <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                             <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                       <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                          <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                             <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </lowClosedExpression>
                              <high xsi:type="ToDateTime">
                                 <operand asType="t:Date" xsi:type="As">
                                    <operand path="high" xsi:type="Property">
                                       <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                          <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                             <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                                <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                   <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </low>
                                          <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                             <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                                <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                   <source path="birthDate" xsi:type="Property">
                                                      <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                   </source>
                                                </operand>
                                                <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                   <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                      <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                         <operand path="abatement" xsi:type="Property">
                                                            <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                         </operand>
                                                      </source>
                                                   </operand>
                                                   <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                                </operand>
                                             </operand>
                                             <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                          </high>
                                       </source>
                                    </operand>
                                 </operand>
                              </high>
                              <highClosedExpression path="highClosed" xsi:type="Property">
                                 <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                       <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                          <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                             <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                       <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                          <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                             <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </highClosedExpression>
                           </then>
                           <else localId="883" locator="439:7-441:32" xsi:type="If">
                              <condition localId="871" locator="439:10-439:50" xsi:type="Is">
                                 <operand localId="868" locator="439:10-439:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="abatement" xsi:type="Property">
                                       <source localId="867" locator="439:10-439:18" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                                 <isTypeSpecifier localId="870" locator="439:33-439:50" xsi:type="IntervalTypeSpecifier">
                                    <pointType localId="869" locator="439:42-439:49" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </isTypeSpecifier>
                              </condition>
                              <then localId="878" locator="440:4-440:62" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="874" locator="440:13-440:35" path="low" xsi:type="Property">
                                    <source localId="873" locator="440:13-440:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="872" locator="440:13-440:21" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </source>
                                 </low>
                                 <high localId="877" locator="440:38-440:61" path="high" xsi:type="Property">
                                    <source localId="876" locator="440:38-440:56" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="875" locator="440:38-440:46" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </source>
                                 </high>
                              </then>
                              <else xsi:type="Interval">
                                 <low xsi:type="As">
                                    <operand path="low" xsi:type="Property">
                                       <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                          <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                          <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </asTypeSpecifier>
                                       </source>
                                    </operand>
                                    <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                       <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </low>
                                 <lowClosedExpression path="lowClosed" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </lowClosedExpression>
                                 <high xsi:type="As">
                                    <operand path="high" xsi:type="Property">
                                       <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                          <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                          <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                             <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                          </asTypeSpecifier>
                                       </source>
                                    </operand>
                                    <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                       <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </high>
                                 <highClosedExpression path="highClosed" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </highClosedExpression>
                              </else>
                           </else>
                        </else>
                     </source>
                  </operand>
               </high>
               <highClosedExpression path="highClosed" xsi:type="Property">
                  <source localId="885" locator="433:7-441:32" xsi:type="If">
                     <condition localId="825" locator="433:10-433:47" xsi:type="Is">
                        <operand localId="823" locator="433:10-433:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand path="abatement" xsi:type="Property">
                              <source localId="822" locator="433:10-433:18" name="condition" xsi:type="OperandRef"/>
                           </operand>
                        </operand>
                        <isTypeSpecifier localId="824" locator="433:33-433:47" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                     </condition>
                     <then xsi:type="Interval">
                        <low xsi:type="ToDateTime">
                           <operand asType="t:Date" xsi:type="As">
                              <operand path="low" xsi:type="Property">
                                 <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                       <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                          <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                       <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                          <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                             <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </operand>
                           </operand>
                        </low>
                        <lowClosedExpression path="lowClosed" xsi:type="Property">
                           <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                 <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                    <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </operand>
                                    <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </low>
                              <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                 <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                    <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                       <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                                 <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                              </high>
                           </source>
                        </lowClosedExpression>
                        <high xsi:type="ToDateTime">
                           <operand asType="t:Date" xsi:type="As">
                              <operand path="high" xsi:type="Property">
                                 <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                                    <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                       <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                          <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </operand>
                                          <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </low>
                                    <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                       <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                          <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                             <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </operand>
                                             <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </operand>
                                       <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                                    </high>
                                 </source>
                              </operand>
                           </operand>
                        </high>
                        <highClosedExpression path="highClosed" xsi:type="Property">
                           <source localId="842" locator="434:3-435:73" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="832" locator="434:12-434:71" xsi:type="Add">
                                 <operand localId="827" locator="434:12-434:28" path="value" xsi:type="Property">
                                    <source path="birthDate" xsi:type="Property">
                                       <source localId="826" locator="434:12-434:18" name="Patient" xsi:type="ExpressionRef"/>
                                    </source>
                                 </operand>
                                 <operand localId="831" locator="434:32-434:71" strict="false" xsi:type="As">
                                    <operand localId="829" locator="434:33-434:51" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="abatement" xsi:type="Property">
                                          <source localId="828" locator="434:33-434:41" name="condition" xsi:type="OperandRef"/>
                                       </operand>
                                    </operand>
                                    <asTypeSpecifier localId="830" locator="434:56-434:70" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </operand>
                              </low>
                              <high localId="841" locator="435:4-435:72" xsi:type="Add">
                                 <operand localId="839" locator="435:4-435:63" xsi:type="Add">
                                    <operand localId="834" locator="435:4-435:20" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="833" locator="435:4-435:10" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="838" locator="435:24-435:63" strict="false" xsi:type="As">
                                       <operand localId="836" locator="435:25-435:43" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="abatement" xsi:type="Property">
                                             <source localId="835" locator="435:25-435:33" name="condition" xsi:type="OperandRef"/>
                                          </operand>
                                       </operand>
                                       <asTypeSpecifier localId="837" locator="435:48-435:62" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </operand>
                                 <operand localId="840" locator="435:67-435:72" value="1" unit="year" xsi:type="Quantity"/>
                              </high>
                           </source>
                        </highClosedExpression>
                     </then>
                     <else localId="884" locator="436:7-441:32" xsi:type="If">
                        <condition localId="847" locator="436:10-436:57" xsi:type="Is">
                           <operand localId="844" locator="436:10-436:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                              <operand path="abatement" xsi:type="Property">
                                 <source localId="843" locator="436:10-436:18" name="condition" xsi:type="OperandRef"/>
                              </operand>
                           </operand>
                           <isTypeSpecifier localId="846" locator="436:33-436:57" xsi:type="IntervalTypeSpecifier">
                              <pointType localId="845" locator="436:42-436:56" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                           </isTypeSpecifier>
                        </condition>
                        <then xsi:type="Interval">
                           <low xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="low" xsi:type="Property">
                                    <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                          <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                             <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                          <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                             <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                   <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </low>
                           <lowClosedExpression path="lowClosed" xsi:type="Property">
                              <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                    <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                       <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                          <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </source>
                                       </operand>
                                       <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                    <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                       <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                          <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                             <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </lowClosedExpression>
                           <high xsi:type="ToDateTime">
                              <operand asType="t:Date" xsi:type="As">
                                 <operand path="high" xsi:type="Property">
                                    <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                       <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                          <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                             <source path="birthDate" xsi:type="Property">
                                                <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                             </source>
                                          </operand>
                                          <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                             <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                                <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                   <operand path="abatement" xsi:type="Property">
                                                      <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                                   </operand>
                                                </source>
                                             </operand>
                                             <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                          </operand>
                                       </low>
                                       <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                          <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                             <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                                <source path="birthDate" xsi:type="Property">
                                                   <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                                </source>
                                             </operand>
                                             <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                                <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                                   <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                      <operand path="abatement" xsi:type="Property">
                                                         <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                      </operand>
                                                   </source>
                                                </operand>
                                                <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                             </operand>
                                          </operand>
                                          <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                       </high>
                                    </source>
                                 </operand>
                              </operand>
                           </high>
                           <highClosedExpression path="highClosed" xsi:type="Property">
                              <source localId="866" locator="437:4-438:79" lowClosed="true" highClosed="false" xsi:type="Interval">
                                 <low localId="855" locator="437:13-437:76" xsi:type="Add">
                                    <operand localId="849" locator="437:13-437:29" path="value" xsi:type="Property">
                                       <source path="birthDate" xsi:type="Property">
                                          <source localId="848" locator="437:13-437:19" name="Patient" xsi:type="ExpressionRef"/>
                                       </source>
                                    </operand>
                                    <operand localId="854" locator="437:33-437:76" strict="false" xsi:type="As">
                                       <operand localId="852" locator="437:34-437:56" path="low" xsi:type="Property">
                                          <source localId="851" locator="437:34-437:52" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="abatement" xsi:type="Property">
                                                <source localId="850" locator="437:34-437:42" name="condition" xsi:type="OperandRef"/>
                                             </operand>
                                          </source>
                                       </operand>
                                       <asTypeSpecifier localId="853" locator="437:61-437:75" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                    </operand>
                                 </low>
                                 <high localId="865" locator="438:5-438:78" xsi:type="Add">
                                    <operand localId="863" locator="438:5-438:69" xsi:type="Add">
                                       <operand localId="857" locator="438:5-438:21" path="value" xsi:type="Property">
                                          <source path="birthDate" xsi:type="Property">
                                             <source localId="856" locator="438:5-438:11" name="Patient" xsi:type="ExpressionRef"/>
                                          </source>
                                       </operand>
                                       <operand localId="862" locator="438:25-438:69" strict="false" xsi:type="As">
                                          <operand localId="860" locator="438:26-438:49" path="high" xsi:type="Property">
                                             <source localId="859" locator="438:26-438:44" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                                <operand path="abatement" xsi:type="Property">
                                                   <source localId="858" locator="438:26-438:34" name="condition" xsi:type="OperandRef"/>
                                                </operand>
                                             </source>
                                          </operand>
                                          <asTypeSpecifier localId="861" locator="438:54-438:68" name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                       </operand>
                                    </operand>
                                    <operand localId="864" locator="438:73-438:78" value="1" unit="year" xsi:type="Quantity"/>
                                 </high>
                              </source>
                           </highClosedExpression>
                        </then>
                        <else localId="883" locator="439:7-441:32" xsi:type="If">
                           <condition localId="871" locator="439:10-439:50" xsi:type="Is">
                              <operand localId="868" locator="439:10-439:28" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="abatement" xsi:type="Property">
                                    <source localId="867" locator="439:10-439:18" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                              <isTypeSpecifier localId="870" locator="439:33-439:50" xsi:type="IntervalTypeSpecifier">
                                 <pointType localId="869" locator="439:42-439:49" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </condition>
                           <then localId="878" locator="440:4-440:62" lowClosed="true" highClosed="false" xsi:type="Interval">
                              <low localId="874" locator="440:13-440:35" path="low" xsi:type="Property">
                                 <source localId="873" locator="440:13-440:31" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="abatement" xsi:type="Property">
                                       <source localId="872" locator="440:13-440:21" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </source>
                              </low>
                              <high localId="877" locator="440:38-440:61" path="high" xsi:type="Property">
                                 <source localId="876" locator="440:38-440:56" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="abatement" xsi:type="Property">
                                       <source localId="875" locator="440:38-440:46" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </source>
                              </high>
                           </then>
                           <else xsi:type="Interval">
                              <low xsi:type="As">
                                 <operand path="low" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </operand>
                                 <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                    <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </low>
                              <lowClosedExpression path="lowClosed" xsi:type="Property">
                                 <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                    <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                    <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </source>
                              </lowClosedExpression>
                              <high xsi:type="As">
                                 <operand path="high" xsi:type="Property">
                                    <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                       <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                       <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                          <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                       </asTypeSpecifier>
                                    </source>
                                 </operand>
                                 <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                    <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    <choice name="t:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </high>
                              <highClosedExpression path="highClosed" xsi:type="Property">
                                 <source localId="882" locator="441:7-441:32" strict="false" xsi:type="As">
                                    <operand localId="879" locator="441:7-441:10" xsi:type="Null"/>
                                    <asTypeSpecifier localId="881" locator="441:15-441:32" xsi:type="IntervalTypeSpecifier">
                                       <pointType localId="880" locator="441:24-441:31" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                    </asTypeSpecifier>
                                 </source>
                              </highClosedExpression>
                           </else>
                        </else>
                     </else>
                  </source>
               </highClosedExpression>
            </else>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="808" locator="430:52-430:67" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="920" locator="449:1-455:87" name="prevalenceInterval" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns an interval representing the normalized prevalence period of a given Condition."/>
            <a:t name="comment" value="Uses the toInterval and abatementInterval functions to determine the widest potential interval from&#xa;onset to abatement as specified in the given Condition. If the condition is active, the resulting interval will have&#xa;a closed ending boundary. If the condition is not active, the resulting interval will have an open ending boundary."/>
            <a:s r="920">
               <a:s>/*
@description: Returns an interval representing the normalized prevalence period of a given Condition.
@comment: Uses the toInterval and abatementInterval functions to determine the widest potential interval from
onset to abatement as specified in the given Condition. If the condition is active, the resulting interval will have
a closed ending boundary. If the condition is not active, the resulting interval will have an open ending boundary.
*/
define fluent function prevalenceInterval(condition </a:s>
               <a:s r="888">
                  <a:s>USCore.Condition</a:s>
               </a:s>
               <a:s>):
</a:s>
               <a:s r="919">
                  <a:s r="919">
                     <a:s>if </a:s>
                     <a:s r="902">
                        <a:s r="897">
                           <a:s r="892">
                              <a:s r="890">
                                 <a:s r="889">
                                    <a:s>condition</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="890">
                                    <a:s>clinicalStatus</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="891">
                                 <a:s>&quot;active&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
  or </a:s>
                           <a:s r="896">
                              <a:s r="894">
                                 <a:s r="893">
                                    <a:s>condition</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="894">
                                    <a:s>clinicalStatus</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="895">
                                 <a:s>&quot;recurrence&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  or </a:s>
                        <a:s r="901">
                           <a:s r="899">
                              <a:s r="898">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="899">
                                 <a:s>clinicalStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="900">
                              <a:s>&quot;relapse&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s> then
  </a:s>
                     <a:s r="910">
                        <a:s>Interval[</a:s>
                        <a:s r="906">
                           <a:s>start of </a:s>
                           <a:s r="905">
                              <a:s r="904">
                                 <a:s r="903">
                                    <a:s>condition</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="904">
                                    <a:s>onset</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="905">
                                 <a:s>toInterval()</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="909">
                           <a:s>end of </a:s>
                           <a:s r="908">
                              <a:s r="907">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="908">
                                 <a:s>abatementInterval()</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>]</a:s>
                     </a:s>
                     <a:s>
else
  </a:s>
                     <a:s r="918">
                        <a:s>Interval[</a:s>
                        <a:s r="914">
                           <a:s>start of </a:s>
                           <a:s r="913">
                              <a:s r="912">
                                 <a:s r="911">
                                    <a:s>condition</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="912">
                                    <a:s>onset</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="913">
                                 <a:s>toInterval()</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="917">
                           <a:s>end of </a:s>
                           <a:s r="916">
                              <a:s r="915">
                                 <a:s>condition</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="916">
                                 <a:s>abatementInterval()</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="919" locator="450:1-455:87" xsi:type="If">
            <condition localId="902" locator="450:4-452:41" xsi:type="Or">
               <operand localId="897" locator="450:4-451:44" xsi:type="Or">
                  <operand localId="892" locator="450:4-450:38" xsi:type="Equivalent">
                     <operand localId="890" locator="450:4-450:27" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="clinicalStatus" xsi:type="Property">
                           <source localId="889" locator="450:4-450:12" name="condition" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                     <operand xsi:type="ToConcept">
                        <operand localId="891" locator="450:31-450:38" name="active" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
                  <operand localId="896" locator="451:6-451:44" xsi:type="Equivalent">
                     <operand localId="894" locator="451:6-451:29" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="clinicalStatus" xsi:type="Property">
                           <source localId="893" locator="451:6-451:14" name="condition" xsi:type="OperandRef"/>
                        </operand>
                     </operand>
                     <operand xsi:type="ToConcept">
                        <operand localId="895" locator="451:33-451:44" name="recurrence" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="901" locator="452:6-452:41" xsi:type="Equivalent">
                  <operand localId="899" locator="452:6-452:29" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="clinicalStatus" xsi:type="Property">
                        <source localId="898" locator="452:6-452:14" name="condition" xsi:type="OperandRef"/>
                     </operand>
                  </operand>
                  <operand xsi:type="ToConcept">
                     <operand localId="900" locator="452:33-452:41" name="relapse" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </condition>
            <then localId="910" locator="453:3-453:87" lowClosed="true" highClosed="true" xsi:type="Interval">
               <low localId="906" locator="453:12-453:48" xsi:type="Start">
                  <operand localId="905" locator="453:21-453:48" name="toInterval" xsi:type="FunctionRef">
                     <operand xsi:type="Case">
                        <caseItem>
                           <when isType="t:DateTime" xsi:type="Is">
                              <operand localId="904" locator="453:21-453:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="onset" xsi:type="Property">
                                    <source localId="903" locator="453:21-453:29" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                           </when>
                           <then xsi:type="As">
                              <operand asType="t:DateTime" xsi:type="As">
                                 <operand localId="904" locator="453:21-453:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="onset" xsi:type="Property">
                                       <source localId="903" locator="453:21-453:29" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                 <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem>
                           <when xsi:type="Is">
                              <operand localId="904" locator="453:21-453:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="onset" xsi:type="Property">
                                    <source localId="903" locator="453:21-453:29" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                              <isTypeSpecifier xsi:type="IntervalTypeSpecifier">
                                 <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </when>
                           <then xsi:type="As">
                              <operand xsi:type="As">
                                 <operand localId="904" locator="453:21-453:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="onset" xsi:type="Property">
                                       <source localId="903" locator="453:21-453:29" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                                    <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </operand>
                              <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                 <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <else xsi:type="Null">
                           <resultTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                              <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              <choice name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              <choice xsi:type="IntervalTypeSpecifier">
                                 <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </choice>
                              <choice xsi:type="IntervalTypeSpecifier">
                                 <pointType name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </choice>
                           </resultTypeSpecifier>
                        </else>
                     </operand>
                  </operand>
               </low>
               <high localId="909" locator="453:51-453:86" xsi:type="End">
                  <operand localId="908" locator="453:58-453:86" name="abatementInterval" xsi:type="FunctionRef">
                     <operand localId="907" locator="453:58-453:66" name="condition" xsi:type="OperandRef"/>
                  </operand>
               </high>
            </then>
            <else localId="918" locator="455:3-455:87" lowClosed="true" highClosed="false" xsi:type="Interval">
               <low localId="914" locator="455:12-455:48" xsi:type="Start">
                  <operand localId="913" locator="455:21-455:48" name="toInterval" xsi:type="FunctionRef">
                     <operand xsi:type="Case">
                        <caseItem>
                           <when isType="t:DateTime" xsi:type="Is">
                              <operand localId="912" locator="455:21-455:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="onset" xsi:type="Property">
                                    <source localId="911" locator="455:21-455:29" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                           </when>
                           <then xsi:type="As">
                              <operand asType="t:DateTime" xsi:type="As">
                                 <operand localId="912" locator="455:21-455:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="onset" xsi:type="Property">
                                       <source localId="911" locator="455:21-455:29" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                              </operand>
                              <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                 <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <caseItem>
                           <when xsi:type="Is">
                              <operand localId="912" locator="455:21-455:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="onset" xsi:type="Property">
                                    <source localId="911" locator="455:21-455:29" name="condition" xsi:type="OperandRef"/>
                                 </operand>
                              </operand>
                              <isTypeSpecifier xsi:type="IntervalTypeSpecifier">
                                 <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </isTypeSpecifier>
                           </when>
                           <then xsi:type="As">
                              <operand xsi:type="As">
                                 <operand localId="912" locator="455:21-455:35" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="onset" xsi:type="Property">
                                       <source localId="911" locator="455:21-455:29" name="condition" xsi:type="OperandRef"/>
                                    </operand>
                                 </operand>
                                 <asTypeSpecifier xsi:type="IntervalTypeSpecifier">
                                    <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </asTypeSpecifier>
                              </operand>
                              <asTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                                 <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 <choice name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                                 <choice xsi:type="IntervalTypeSpecifier">
                                    <pointType name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                                 </choice>
                              </asTypeSpecifier>
                           </then>
                        </caseItem>
                        <else xsi:type="Null">
                           <resultTypeSpecifier xsi:type="ChoiceTypeSpecifier">
                              <choice name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              <choice name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              <choice xsi:type="IntervalTypeSpecifier">
                                 <pointType name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                              </choice>
                              <choice xsi:type="IntervalTypeSpecifier">
                                 <pointType name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
                              </choice>
                           </resultTypeSpecifier>
                        </else>
                     </operand>
                  </operand>
               </low>
               <high localId="917" locator="455:51-455:86" xsi:type="End">
                  <operand localId="916" locator="455:58-455:86" name="abatementInterval" xsi:type="FunctionRef">
                     <operand localId="915" locator="455:58-455:66" name="condition" xsi:type="OperandRef"/>
                  </operand>
               </high>
            </else>
         </expression>
         <operand name="condition">
            <operandTypeSpecifier localId="888" locator="449:53-449:68" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="926" locator="463:1-464:23" name="getId" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns the tail of the given uri (i.e. everything after the last slash in the URI)."/>
            <a:t name="comment" value="This function can be used to determine the logical id of a given resource. It can be used in&#xa;a single-server environment to trace references. However, this function does not attempt to resolve&#xa;or distinguish the base of the given url, and so cannot be used safely in multi-server environments."/>
            <a:s r="926">
               <a:s>/*
@description: Returns the tail of the given uri (i.e. everything after the last slash in the URI).
@comment: This function can be used to determine the logical id of a given resource. It can be used in
a single-server environment to trace references. However, this function does not attempt to resolve
or distinguish the base of the given url, and so cannot be used safely in multi-server environments.
*/
define fluent function getId(uri </a:s>
               <a:s r="921">
                  <a:s>String</a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="925">
                  <a:s r="925">
                     <a:s>Last(</a:s>
                     <a:s r="924">
                        <a:s>Split(</a:s>
                        <a:s r="922">
                           <a:s>uri</a:s>
                        </a:s>
                        <a:s>, </a:s>
                        <a:s r="923">
                           <a:s>'/'</a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="925" locator="464:3-464:23" xsi:type="Last">
            <source localId="924" locator="464:8-464:22" xsi:type="Split">
               <stringToSplit localId="922" locator="464:14-464:16" name="uri" xsi:type="OperandRef"/>
               <separator localId="923" locator="464:19-464:21" valueType="t:String" value="/" xsi:type="Literal"/>
            </source>
         </expression>
         <operand name="uri">
            <operandTypeSpecifier localId="921" locator="463:34-463:39" name="t:String" xsi:type="NamedTypeSpecifier"/>
         </operand>
      </def>
      <def localId="939" locator="470:1-473:3" name="hasStart" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Given an interval, return true if the interval has a starting boundary specified&#xa;(i.e. the start of the interval is not null and not the minimum DateTime value)"/>
            <a:s r="939">
               <a:s>/*
@description: Given an interval, return true if the interval has a starting boundary specified
(i.e. the start of the interval is not null and not the minimum DateTime value)
*/
define fluent function hasStart(period </a:s>
               <a:s r="928">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="927">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s> ):
  </a:s>
               <a:s r="938">
                  <a:s r="938">
                     <a:s>not </a:s>
                     <a:s r="937">
                        <a:s>( </a:s>
                        <a:s r="937">
                           <a:s r="931">
                              <a:s r="930">
                                 <a:s>start of </a:s>
                                 <a:s r="929">
                                    <a:s>period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> is null</a:s>
                           </a:s>
                           <a:s>
      or </a:s>
                           <a:s r="936">
                              <a:s r="933">
                                 <a:s>start of </a:s>
                                 <a:s r="932">
                                    <a:s>period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> = </a:s>
                              <a:s r="935">
                                 <a:s>minimum </a:s>
                                 <a:s r="934">
                                    <a:s>DateTime</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="938" locator="471:3-473:3" xsi:type="Not">
            <operand localId="937" locator="471:7-473:3" xsi:type="Or">
               <operand localId="931" locator="471:9-471:31" xsi:type="IsNull">
                  <operand localId="930" locator="471:9-471:23" xsi:type="Start">
                     <operand localId="929" locator="471:18-471:23" name="period" xsi:type="OperandRef"/>
                  </operand>
               </operand>
               <operand localId="936" locator="472:10-472:43" xsi:type="Equal">
                  <operand localId="933" locator="472:10-472:24" xsi:type="Start">
                     <operand localId="932" locator="472:19-472:24" name="period" xsi:type="OperandRef"/>
                  </operand>
                  <operand localId="935" locator="472:28-472:43" valueType="t:DateTime" xsi:type="MinValue"/>
               </operand>
            </operand>
         </expression>
         <operand name="period">
            <operandTypeSpecifier localId="928" locator="470:40-470:57" xsi:type="IntervalTypeSpecifier">
               <pointType localId="927" locator="470:49-470:56" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="952" locator="479:1-483:3" name="hasEnd" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Given an interval, returns true if the interval has an ending boundary specified&#xa;(i.e. the end of the interval is not null and not the maximum DateTime value)"/>
            <a:s r="952">
               <a:s>/*
@description: Given an interval, returns true if the interval has an ending boundary specified
(i.e. the end of the interval is not null and not the maximum DateTime value)
*/
define fluent function hasEnd(period </a:s>
               <a:s r="941">
                  <a:s>Interval&lt;</a:s>
                  <a:s r="940">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s> ):
  </a:s>
               <a:s r="951">
                  <a:s r="951">
                     <a:s>not </a:s>
                     <a:s r="950">
                        <a:s>(
    </a:s>
                        <a:s r="950">
                           <a:s r="944">
                              <a:s r="943">
                                 <a:s>end of </a:s>
                                 <a:s r="942">
                                    <a:s>period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> is null</a:s>
                           </a:s>
                           <a:s>
      or </a:s>
                           <a:s r="949">
                              <a:s r="946">
                                 <a:s>end of </a:s>
                                 <a:s r="945">
                                    <a:s>period</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> = </a:s>
                              <a:s r="948">
                                 <a:s>maximum </a:s>
                                 <a:s r="947">
                                    <a:s>DateTime</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
  )</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="951" locator="480:3-483:3" xsi:type="Not">
            <operand localId="950" locator="480:7-483:3" xsi:type="Or">
               <operand localId="944" locator="481:5-481:25" xsi:type="IsNull">
                  <operand localId="943" locator="481:5-481:17" xsi:type="End">
                     <operand localId="942" locator="481:12-481:17" name="period" xsi:type="OperandRef"/>
                  </operand>
               </operand>
               <operand localId="949" locator="482:10-482:41" xsi:type="Equal">
                  <operand localId="946" locator="482:10-482:22" xsi:type="End">
                     <operand localId="945" locator="482:17-482:22" name="period" xsi:type="OperandRef"/>
                  </operand>
                  <operand localId="948" locator="482:26-482:41" valueType="t:DateTime" xsi:type="MaxValue"/>
               </operand>
            </operand>
         </expression>
         <operand name="period">
            <operandTypeSpecifier localId="941" locator="479:38-479:55" xsi:type="IntervalTypeSpecifier">
               <pointType localId="940" locator="479:47-479:54" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="972" locator="489:1-493:26" name="latest" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Given an interval, returns the ending point if the interval has an ending boundary specified,&#xa;otherwise, returns the starting point"/>
            <a:s r="972">
               <a:s>/*
@description: Given an interval, returns the ending point if the interval has an ending boundary specified,
otherwise, returns the starting point
*/
define fluent function latest(choice </a:s>
               <a:s r="959">
                  <a:s>Choice&lt;</a:s>
                  <a:s r="953">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="954">
                     <a:s>Quantity</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="956">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="955">
                        <a:s>DateTime</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="958">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="957">
                        <a:s>Quantity</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s> ):
  </a:s>
               <a:s r="971">
                  <a:s r="971">
                     <a:s>
                        <a:s r="962">
                           <a:s r="961">
                              <a:s>(</a:s>
                              <a:s r="961">
                                 <a:s r="960">
                                    <a:s>choice</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="961">
                                    <a:s>toInterval()</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s> period</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="970">
                        <a:s>return
      </a:s>
                        <a:s r="969">
                           <a:s>if </a:s>
                           <a:s r="964">
                              <a:s>(</a:s>
                              <a:s r="964">
                                 <a:s r="963">
                                    <a:s>period</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="964">
                                    <a:s>hasEnd()</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s> then </a:s>
                           <a:s r="966">
                              <a:s>end of </a:s>
                              <a:s r="965">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      else </a:s>
                           <a:s r="968">
                              <a:s>start of </a:s>
                              <a:s r="967">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="971" locator="490:3-493:26" xsi:type="Query">
            <source localId="962" locator="490:3-490:30" alias="period">
               <expression localId="961" locator="490:3-490:23" name="toInterval" xsi:type="FunctionRef">
                  <operand localId="960" locator="490:4-490:9" name="choice" xsi:type="OperandRef"/>
               </expression>
            </source>
            <return localId="970" locator="491:5-493:26">
               <expression localId="969" locator="492:7-493:26" xsi:type="If">
                  <condition localId="964" locator="492:10-492:26" name="hasEnd" xsi:type="FunctionRef">
                     <operand localId="963" locator="492:11-492:16" name="period" xsi:type="AliasRef"/>
                  </condition>
                  <then localId="966" locator="492:33-492:45" xsi:type="End">
                     <operand localId="965" locator="492:40-492:45" name="period" xsi:type="AliasRef"/>
                  </then>
                  <else localId="968" locator="493:12-493:26" xsi:type="Start">
                     <operand localId="967" locator="493:21-493:26" name="period" xsi:type="AliasRef"/>
                  </else>
               </expression>
            </return>
         </expression>
         <operand name="choice">
            <operandTypeSpecifier localId="959" locator="489:38-489:103" xsi:type="ChoiceTypeSpecifier">
               <choice localId="953" locator="489:45-489:52" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               <choice localId="954" locator="489:55-489:62" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
               <choice localId="956" locator="489:65-489:82" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="955" locator="489:74-489:81" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </choice>
               <choice localId="958" locator="489:85-489:102" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="957" locator="489:94-489:101" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
               </choice>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="992" locator="499:1-503:24" name="earliest" context="Patient" accessLevel="Public" fluent="true" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Given an interval, return the starting point if the interval has a starting boundary specified,&#xa;otherwise, return the ending point"/>
            <a:s r="992">
               <a:s>/*
@description: Given an interval, return the starting point if the interval has a starting boundary specified,
otherwise, return the ending point
*/
define fluent function earliest(choice </a:s>
               <a:s r="979">
                  <a:s>Choice&lt;</a:s>
                  <a:s r="973">
                     <a:s>DateTime</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="974">
                     <a:s>Quantity</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="976">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="975">
                        <a:s>DateTime</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="978">
                     <a:s>Interval&lt;</a:s>
                     <a:s r="977">
                        <a:s>Quantity</a:s>
                     </a:s>
                     <a:s>></a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s> ):
  </a:s>
               <a:s r="991">
                  <a:s r="991">
                     <a:s>
                        <a:s r="982">
                           <a:s r="981">
                              <a:s>(</a:s>
                              <a:s r="981">
                                 <a:s r="980">
                                    <a:s>choice</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="981">
                                    <a:s>toInterval()</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s> period</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
    </a:s>
                     <a:s r="990">
                        <a:s>return
      </a:s>
                        <a:s r="989">
                           <a:s>if </a:s>
                           <a:s r="984">
                              <a:s>(</a:s>
                              <a:s r="984">
                                 <a:s r="983">
                                    <a:s>period</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="984">
                                    <a:s>hasStart()</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>)</a:s>
                           </a:s>
                           <a:s> then </a:s>
                           <a:s r="986">
                              <a:s>start of </a:s>
                              <a:s r="985">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      else </a:s>
                           <a:s r="988">
                              <a:s>end of </a:s>
                              <a:s r="987">
                                 <a:s>period</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="991" locator="500:3-503:24" xsi:type="Query">
            <source localId="982" locator="500:3-500:30" alias="period">
               <expression localId="981" locator="500:3-500:23" name="toInterval" xsi:type="FunctionRef">
                  <operand localId="980" locator="500:4-500:9" name="choice" xsi:type="OperandRef"/>
               </expression>
            </source>
            <return localId="990" locator="501:5-503:24">
               <expression localId="989" locator="502:7-503:24" xsi:type="If">
                  <condition localId="984" locator="502:10-502:28" name="hasStart" xsi:type="FunctionRef">
                     <operand localId="983" locator="502:11-502:16" name="period" xsi:type="AliasRef"/>
                  </condition>
                  <then localId="986" locator="502:35-502:49" xsi:type="Start">
                     <operand localId="985" locator="502:44-502:49" name="period" xsi:type="AliasRef"/>
                  </then>
                  <else localId="988" locator="503:12-503:24" xsi:type="End">
                     <operand localId="987" locator="503:19-503:24" name="period" xsi:type="AliasRef"/>
                  </else>
               </expression>
            </return>
         </expression>
         <operand name="choice">
            <operandTypeSpecifier localId="979" locator="499:40-499:105" xsi:type="ChoiceTypeSpecifier">
               <choice localId="973" locator="499:47-499:54" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               <choice localId="974" locator="499:57-499:64" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
               <choice localId="976" locator="499:67-499:84" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="975" locator="499:76-499:83" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
               </choice>
               <choice localId="978" locator="499:87-499:104" xsi:type="IntervalTypeSpecifier">
                  <pointType localId="977" locator="499:96-499:103" name="fhir:Quantity" xsi:type="NamedTypeSpecifier"/>
               </choice>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1002" locator="508:1-512:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns the most recent Condition"/>
            <a:s r="1002">
               <a:s>/*
@description: Returns the most recent Condition
*/
define function MostRecent(conditions </a:s>
               <a:s r="994">
                  <a:s>List&lt;</a:s>
                  <a:s r="993">
                     <a:s>USCore.Condition</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1001">
                  <a:s r="1001">
                     <a:s>Last(
    </a:s>
                     <a:s r="1000">
                        <a:s>
                           <a:s r="996">
                              <a:s r="995">
                                 <a:s>
                                    <a:s>conditions</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> C</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="999">
                           <a:s>sort by </a:s>
                           <a:s r="998">
                              <a:s r="997">
                                 <a:s>recordedDate</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1001" locator="509:3-512:3" xsi:type="Last">
            <source localId="1000" locator="510:5-511:26" xsi:type="Query">
               <source localId="996" locator="510:5-510:16" alias="C">
                  <expression localId="995" locator="510:5-510:14" name="conditions" xsi:type="OperandRef"/>
               </source>
               <sort localId="999" locator="511:7-511:26">
                  <by localId="998" locator="511:15-511:26" direction="asc" xsi:type="ByExpression">
                     <expression localId="997" locator="511:15-511:26" path="value" xsi:type="Property">
                        <source name="recordedDate" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="conditions">
            <operandTypeSpecifier localId="994" locator="508:39-508:60" xsi:type="ListTypeSpecifier">
               <elementType localId="993" locator="508:44-508:59" name="fhir:Condition" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1012" locator="517:1-521:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Return the most recent Observation"/>
            <a:s r="1012">
               <a:s>/*
@description: Return the most recent Observation
*/
define function MostRecent(observations </a:s>
               <a:s r="1004">
                  <a:s>List&lt;</a:s>
                  <a:s r="1003">
                     <a:s>Observation</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1011">
                  <a:s r="1011">
                     <a:s>Last(
    </a:s>
                     <a:s r="1010">
                        <a:s>
                           <a:s r="1006">
                              <a:s r="1005">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1009">
                           <a:s>sort by </a:s>
                           <a:s r="1008">
                              <a:s r="1007">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1011" locator="518:3-521:3" xsi:type="Last">
            <source localId="1010" locator="519:5-520:20" xsi:type="Query">
               <source localId="1006" locator="519:5-519:18" alias="O">
                  <expression localId="1005" locator="519:5-519:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1009" locator="520:7-520:20">
                  <by localId="1008" locator="520:15-520:20" direction="asc" path="issued" xsi:type="ByColumn"/>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1004" locator="517:41-517:57" xsi:type="ListTypeSpecifier">
               <elementType localId="1003" locator="517:46-517:56" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1022" locator="523:1-527:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1022">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1014">
                  <a:s>List&lt;</a:s>
                  <a:s r="1013">
                     <a:s>&quot;SmokingStatusProfile&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1021">
                  <a:s r="1021">
                     <a:s>Last(
    </a:s>
                     <a:s r="1020">
                        <a:s>
                           <a:s r="1016">
                              <a:s r="1015">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1019">
                           <a:s>sort by </a:s>
                           <a:s r="1018">
                              <a:s r="1017">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1021" locator="524:3-527:3" xsi:type="Last">
            <source localId="1020" locator="525:5-526:20" xsi:type="Query">
               <source localId="1016" locator="525:5-525:18" alias="O">
                  <expression localId="1015" locator="525:5-525:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1019" locator="526:7-526:20">
                  <by localId="1018" locator="526:15-526:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1017" locator="526:15-526:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1014" locator="523:41-523:68" xsi:type="ListTypeSpecifier">
               <elementType localId="1013" locator="523:46-523:67" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1032" locator="529:1-533:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1032">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1024">
                  <a:s>List&lt;</a:s>
                  <a:s r="1023">
                     <a:s>&quot;PulseOximetryProfile&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1031">
                  <a:s r="1031">
                     <a:s>Last(
    </a:s>
                     <a:s r="1030">
                        <a:s>
                           <a:s r="1026">
                              <a:s r="1025">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1029">
                           <a:s>sort by </a:s>
                           <a:s r="1028">
                              <a:s r="1027">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1031" locator="530:3-533:3" xsi:type="Last">
            <source localId="1030" locator="531:5-532:20" xsi:type="Query">
               <source localId="1026" locator="531:5-531:18" alias="O">
                  <expression localId="1025" locator="531:5-531:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1029" locator="532:7-532:20">
                  <by localId="1028" locator="532:15-532:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1027" locator="532:15-532:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1024" locator="529:41-529:68" xsi:type="ListTypeSpecifier">
               <elementType localId="1023" locator="529:46-529:67" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1042" locator="535:1-539:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1042">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1034">
                  <a:s>List&lt;</a:s>
                  <a:s r="1033">
                     <a:s>&quot;PediatricWeightForHeightObservationProfile&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1041">
                  <a:s r="1041">
                     <a:s>Last(
    </a:s>
                     <a:s r="1040">
                        <a:s>
                           <a:s r="1036">
                              <a:s r="1035">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1039">
                           <a:s>sort by </a:s>
                           <a:s r="1038">
                              <a:s r="1037">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1041" locator="536:3-539:3" xsi:type="Last">
            <source localId="1040" locator="537:5-538:20" xsi:type="Query">
               <source localId="1036" locator="537:5-537:18" alias="O">
                  <expression localId="1035" locator="537:5-537:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1039" locator="538:7-538:20">
                  <by localId="1038" locator="538:15-538:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1037" locator="538:15-538:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1034" locator="535:41-535:90" xsi:type="ListTypeSpecifier">
               <elementType localId="1033" locator="535:46-535:89" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1052" locator="541:3-545:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1052">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1044">
                  <a:s>List&lt;</a:s>
                  <a:s r="1043">
                     <a:s>&quot;PediatricBMIforAgeObservationProfile&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1051">
                  <a:s r="1051">
                     <a:s>Last(
    </a:s>
                     <a:s r="1050">
                        <a:s>
                           <a:s r="1046">
                              <a:s r="1045">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1049">
                           <a:s>sort by </a:s>
                           <a:s r="1048">
                              <a:s r="1047">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1051" locator="542:3-545:3" xsi:type="Last">
            <source localId="1050" locator="543:5-544:20" xsi:type="Query">
               <source localId="1046" locator="543:5-543:18" alias="O">
                  <expression localId="1045" locator="543:5-543:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1049" locator="544:7-544:20">
                  <by localId="1048" locator="544:15-544:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1047" locator="544:15-544:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1044" locator="541:43-541:86" xsi:type="ListTypeSpecifier">
               <elementType localId="1043" locator="541:48-541:85" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1062" locator="547:1-551:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1062">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1054">
                  <a:s>List&lt;</a:s>
                  <a:s r="1053">
                     <a:s>&quot;LaboratoryResultObservationProfile&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1061">
                  <a:s r="1061">
                     <a:s>Last(
    </a:s>
                     <a:s r="1060">
                        <a:s>
                           <a:s r="1056">
                              <a:s r="1055">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1059">
                           <a:s>sort by </a:s>
                           <a:s r="1058">
                              <a:s r="1057">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1061" locator="548:3-551:3" xsi:type="Last">
            <source localId="1060" locator="549:5-550:20" xsi:type="Query">
               <source localId="1056" locator="549:5-549:18" alias="O">
                  <expression localId="1055" locator="549:5-549:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1059" locator="550:7-550:20">
                  <by localId="1058" locator="550:15-550:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1057" locator="550:15-550:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1054" locator="547:41-547:82" xsi:type="ListTypeSpecifier">
               <elementType localId="1053" locator="547:46-547:81" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1072" locator="553:1-557:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1072">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1064">
                  <a:s>List&lt;</a:s>
                  <a:s r="1063">
                     <a:s>&quot;observation-vitalspanel&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1071">
                  <a:s r="1071">
                     <a:s>Last(
    </a:s>
                     <a:s r="1070">
                        <a:s>
                           <a:s r="1066">
                              <a:s r="1065">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1069">
                           <a:s>sort by </a:s>
                           <a:s r="1068">
                              <a:s r="1067">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1071" locator="554:3-557:3" xsi:type="Last">
            <source localId="1070" locator="555:5-556:20" xsi:type="Query">
               <source localId="1066" locator="555:5-555:18" alias="O">
                  <expression localId="1065" locator="555:5-555:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1069" locator="556:7-556:20">
                  <by localId="1068" locator="556:15-556:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1067" locator="556:15-556:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1064" locator="553:41-553:71" xsi:type="ListTypeSpecifier">
               <elementType localId="1063" locator="553:46-553:70" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1082" locator="559:1-563:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1082">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1074">
                  <a:s>List&lt;</a:s>
                  <a:s r="1073">
                     <a:s>&quot;observation-resprate&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1081">
                  <a:s r="1081">
                     <a:s>Last(
    </a:s>
                     <a:s r="1080">
                        <a:s>
                           <a:s r="1076">
                              <a:s r="1075">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1079">
                           <a:s>sort by </a:s>
                           <a:s r="1078">
                              <a:s r="1077">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1081" locator="560:3-563:3" xsi:type="Last">
            <source localId="1080" locator="561:5-562:20" xsi:type="Query">
               <source localId="1076" locator="561:5-561:18" alias="O">
                  <expression localId="1075" locator="561:5-561:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1079" locator="562:7-562:20">
                  <by localId="1078" locator="562:15-562:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1077" locator="562:15-562:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1074" locator="559:41-559:68" xsi:type="ListTypeSpecifier">
               <elementType localId="1073" locator="559:46-559:67" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1092" locator="565:3-569:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1092">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1084">
                  <a:s>List&lt;</a:s>
                  <a:s r="1083">
                     <a:s>&quot;observation-heartrate&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1091">
                  <a:s r="1091">
                     <a:s>Last(
    </a:s>
                     <a:s r="1090">
                        <a:s>
                           <a:s r="1086">
                              <a:s r="1085">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1089">
                           <a:s>sort by </a:s>
                           <a:s r="1088">
                              <a:s r="1087">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1091" locator="566:3-569:3" xsi:type="Last">
            <source localId="1090" locator="567:5-568:20" xsi:type="Query">
               <source localId="1086" locator="567:5-567:18" alias="O">
                  <expression localId="1085" locator="567:5-567:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1089" locator="568:7-568:20">
                  <by localId="1088" locator="568:15-568:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1087" locator="568:15-568:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1084" locator="565:43-565:71" xsi:type="ListTypeSpecifier">
               <elementType localId="1083" locator="565:48-565:70" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1102" locator="571:3-575:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1102">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1094">
                  <a:s>List&lt;</a:s>
                  <a:s r="1093">
                     <a:s>&quot;observation-oxygensat&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1101">
                  <a:s r="1101">
                     <a:s>Last(
    </a:s>
                     <a:s r="1100">
                        <a:s>
                           <a:s r="1096">
                              <a:s r="1095">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1099">
                           <a:s>sort by </a:s>
                           <a:s r="1098">
                              <a:s r="1097">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1101" locator="572:3-575:3" xsi:type="Last">
            <source localId="1100" locator="573:5-574:20" xsi:type="Query">
               <source localId="1096" locator="573:5-573:18" alias="O">
                  <expression localId="1095" locator="573:5-573:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1099" locator="574:7-574:20">
                  <by localId="1098" locator="574:15-574:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1097" locator="574:15-574:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1094" locator="571:43-571:71" xsi:type="ListTypeSpecifier">
               <elementType localId="1093" locator="571:48-571:70" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1112" locator="577:3-581:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1112">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1104">
                  <a:s>List&lt;</a:s>
                  <a:s r="1103">
                     <a:s>&quot;observation-bodytemp&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1111">
                  <a:s r="1111">
                     <a:s>Last(
    </a:s>
                     <a:s r="1110">
                        <a:s>
                           <a:s r="1106">
                              <a:s r="1105">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1109">
                           <a:s>sort by </a:s>
                           <a:s r="1108">
                              <a:s r="1107">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1111" locator="578:3-581:3" xsi:type="Last">
            <source localId="1110" locator="579:5-580:20" xsi:type="Query">
               <source localId="1106" locator="579:5-579:18" alias="O">
                  <expression localId="1105" locator="579:5-579:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1109" locator="580:7-580:20">
                  <by localId="1108" locator="580:15-580:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1107" locator="580:15-580:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1104" locator="577:43-577:70" xsi:type="ListTypeSpecifier">
               <elementType localId="1103" locator="577:48-577:69" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1122" locator="583:3-587:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1122">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1114">
                  <a:s>List&lt;</a:s>
                  <a:s r="1113">
                     <a:s>&quot;observation-headcircum&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1121">
                  <a:s r="1121">
                     <a:s>Last(
    </a:s>
                     <a:s r="1120">
                        <a:s>
                           <a:s r="1116">
                              <a:s r="1115">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1119">
                           <a:s>sort by </a:s>
                           <a:s r="1118">
                              <a:s r="1117">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1121" locator="584:3-587:3" xsi:type="Last">
            <source localId="1120" locator="585:5-586:20" xsi:type="Query">
               <source localId="1116" locator="585:5-585:18" alias="O">
                  <expression localId="1115" locator="585:5-585:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1119" locator="586:7-586:20">
                  <by localId="1118" locator="586:15-586:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1117" locator="586:15-586:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1114" locator="583:43-583:72" xsi:type="ListTypeSpecifier">
               <elementType localId="1113" locator="583:48-583:71" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1132" locator="589:3-593:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1132">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1124">
                  <a:s>List&lt;</a:s>
                  <a:s r="1123">
                     <a:s>&quot;observation-bp&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1131">
                  <a:s r="1131">
                     <a:s>Last(
    </a:s>
                     <a:s r="1130">
                        <a:s>
                           <a:s r="1126">
                              <a:s r="1125">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1129">
                           <a:s>sort by </a:s>
                           <a:s r="1128">
                              <a:s r="1127">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1131" locator="590:3-593:3" xsi:type="Last">
            <source localId="1130" locator="591:5-592:20" xsi:type="Query">
               <source localId="1126" locator="591:5-591:18" alias="O">
                  <expression localId="1125" locator="591:5-591:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1129" locator="592:7-592:20">
                  <by localId="1128" locator="592:15-592:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1127" locator="592:15-592:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1124" locator="589:43-589:64" xsi:type="ListTypeSpecifier">
               <elementType localId="1123" locator="589:48-589:63" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1142" locator="595:1-599:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1142">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1134">
                  <a:s>List&lt;</a:s>
                  <a:s r="1133">
                     <a:s>&quot;observation-bmi&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1141">
                  <a:s r="1141">
                     <a:s>Last(
    </a:s>
                     <a:s r="1140">
                        <a:s>
                           <a:s r="1136">
                              <a:s r="1135">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1139">
                           <a:s>sort by </a:s>
                           <a:s r="1138">
                              <a:s r="1137">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1141" locator="596:3-599:3" xsi:type="Last">
            <source localId="1140" locator="597:5-598:20" xsi:type="Query">
               <source localId="1136" locator="597:5-597:18" alias="O">
                  <expression localId="1135" locator="597:5-597:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1139" locator="598:7-598:20">
                  <by localId="1138" locator="598:15-598:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1137" locator="598:15-598:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1134" locator="595:41-595:63" xsi:type="ListTypeSpecifier">
               <elementType localId="1133" locator="595:46-595:62" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1152" locator="601:1-605:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1152">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1144">
                  <a:s>List&lt;</a:s>
                  <a:s r="1143">
                     <a:s>&quot;observation-bodyheight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1151">
                  <a:s r="1151">
                     <a:s>Last(
    </a:s>
                     <a:s r="1150">
                        <a:s>
                           <a:s r="1146">
                              <a:s r="1145">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1149">
                           <a:s>sort by </a:s>
                           <a:s r="1148">
                              <a:s r="1147">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1151" locator="602:3-605:3" xsi:type="Last">
            <source localId="1150" locator="603:5-604:20" xsi:type="Query">
               <source localId="1146" locator="603:5-603:18" alias="O">
                  <expression localId="1145" locator="603:5-603:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1149" locator="604:7-604:20">
                  <by localId="1148" locator="604:15-604:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1147" locator="604:15-604:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1144" locator="601:41-601:70" xsi:type="ListTypeSpecifier">
               <elementType localId="1143" locator="601:46-601:69" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1162" locator="607:1-611:3" name="MostRecent" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1162">
               <a:s>define function MostRecent(observations </a:s>
               <a:s r="1154">
                  <a:s>List&lt;</a:s>
                  <a:s r="1153">
                     <a:s>&quot;observation-bodyweight&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1161">
                  <a:s r="1161">
                     <a:s>Last(
    </a:s>
                     <a:s r="1160">
                        <a:s>
                           <a:s r="1156">
                              <a:s r="1155">
                                 <a:s>
                                    <a:s>observations</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> O</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1159">
                           <a:s>sort by </a:s>
                           <a:s r="1158">
                              <a:s r="1157">
                                 <a:s>issued</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1161" locator="608:3-611:3" xsi:type="Last">
            <source localId="1160" locator="609:5-610:20" xsi:type="Query">
               <source localId="1156" locator="609:5-609:18" alias="O">
                  <expression localId="1155" locator="609:5-609:16" name="observations" xsi:type="OperandRef"/>
               </source>
               <sort localId="1159" locator="610:7-610:20">
                  <by localId="1158" locator="610:15-610:20" direction="asc" xsi:type="ByExpression">
                     <expression localId="1157" locator="610:15-610:20" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="observations">
            <operandTypeSpecifier localId="1154" locator="607:41-607:70" xsi:type="ListTypeSpecifier">
               <elementType localId="1153" locator="607:46-607:69" name="fhir:Observation" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1172" locator="613:1-617:3" name="MostRecentMR" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1172">
               <a:s>define function MostRecentMR(medicationRequests </a:s>
               <a:s r="1164">
                  <a:s>List&lt;</a:s>
                  <a:s r="1163">
                     <a:s>&quot;MedicationRequestProfile&quot;</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1171">
                  <a:s r="1171">
                     <a:s>Last(
    </a:s>
                     <a:s r="1170">
                        <a:s>
                           <a:s r="1166">
                              <a:s r="1165">
                                 <a:s>
                                    <a:s>medicationRequests</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> MR</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1169">
                           <a:s>sort by </a:s>
                           <a:s r="1168">
                              <a:s r="1167">
                                 <a:s>authoredOn</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1171" locator="614:3-617:3" xsi:type="Last">
            <source localId="1170" locator="615:5-616:24" xsi:type="Query">
               <source localId="1166" locator="615:5-615:25" alias="MR">
                  <expression localId="1165" locator="615:5-615:22" name="medicationRequests" xsi:type="OperandRef"/>
               </source>
               <sort localId="1169" locator="616:7-616:24">
                  <by localId="1168" locator="616:15-616:24" direction="asc" xsi:type="ByExpression">
                     <expression localId="1167" locator="616:15-616:24" path="value" xsi:type="Property">
                        <source name="authoredOn" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="medicationRequests">
            <operandTypeSpecifier localId="1164" locator="613:49-613:80" xsi:type="ListTypeSpecifier">
               <elementType localId="1163" locator="613:54-613:79" name="fhir:MedicationRequest" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1186" locator="619:1-623:3" name="MostRecentSR" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1186">
               <a:s>define function MostRecentSR(serviceRequests </a:s>
               <a:s r="1174">
                  <a:s>List&lt;</a:s>
                  <a:s r="1173">
                     <a:s>FHIR.ServiceRequest</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1185">
                  <a:s r="1185">
                     <a:s>Last(
    </a:s>
                     <a:s r="1184">
                        <a:s>
                           <a:s r="1176">
                              <a:s r="1175">
                                 <a:s>
                                    <a:s>serviceRequests</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> SR</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      </a:s>
                        <a:s r="1183">
                           <a:s>sort by </a:s>
                           <a:s r="1182">
                              <a:s r="1181">
                                 <a:s>(</a:s>
                                 <a:s r="1181">
                                    <a:s r="1179">
                                       <a:s r="1177">
                                          <a:s>FHIRHelpers</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="1179">
                                          <a:s>ToDateTime(</a:s>
                                          <a:s r="1178">
                                             <a:s>authoredOn</a:s>
                                          </a:s>
                                          <a:s>)</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> as </a:s>
                                    <a:s r="1180">
                                       <a:s>DateTime</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
  )</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1185" locator="620:3-623:3" xsi:type="Last">
            <source localId="1184" locator="621:5-622:62" xsi:type="Query">
               <source localId="1176" locator="621:5-621:22" alias="SR">
                  <expression localId="1175" locator="621:5-621:19" name="serviceRequests" xsi:type="OperandRef"/>
               </source>
               <sort localId="1183" locator="622:7-622:62">
                  <by localId="1182" locator="622:15-622:62" direction="asc" xsi:type="ByExpression">
                     <expression localId="1181" locator="622:15-622:62" strict="false" xsi:type="As">
                        <operand localId="1179" locator="622:16-622:49" name="ToDateTime" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand localId="1178" locator="622:39-622:48" name="authoredOn" xsi:type="IdentifierRef"/>
                        </operand>
                        <asTypeSpecifier localId="1180" locator="622:54-622:61" name="t:DateTime" xsi:type="NamedTypeSpecifier"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
         <operand name="serviceRequests">
            <operandTypeSpecifier localId="1174" locator="619:46-619:70" xsi:type="ListTypeSpecifier">
               <elementType localId="1173" locator="619:51-619:69" name="fhir:ServiceRequest" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
      <def localId="1197" locator="626:1-627:57" name="Mobile" context="Patient" accessLevel="Public" xsi:type="FunctionDef">
         <annotation xsi:type="a:Annotation">
            <a:s r="1197">
               <a:s>define function Mobile(contactPoints </a:s>
               <a:s r="1188">
                  <a:s>List&lt;</a:s>
                  <a:s r="1187">
                     <a:s>USCore.ContactPoint</a:s>
                  </a:s>
                  <a:s>></a:s>
               </a:s>
               <a:s>):
  </a:s>
               <a:s r="1196">
                  <a:s r="1196">
                     <a:s>singleton from </a:s>
                     <a:s r="1195">
                        <a:s>(</a:s>
                        <a:s r="1195">
                           <a:s>
                              <a:s r="1190">
                                 <a:s r="1189">
                                    <a:s>
                                       <a:s>contactPoints</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> P</a:s>
                              </a:s>
                           </a:s>
                           <a:s> </a:s>
                           <a:s r="1194">
                              <a:s>where </a:s>
                              <a:s r="1194">
                                 <a:s r="1192">
                                    <a:s r="1191">
                                       <a:s>P</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="1192">
                                       <a:s>use</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s> = </a:s>
                                 <a:s r="1193">
                                    <a:s>'mobile'</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>)</a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="1196" locator="627:3-627:57" xsi:type="SingletonFrom">
            <operand localId="1195" locator="627:18-627:57" xsi:type="Query">
               <source localId="1190" locator="627:19-627:33" alias="P">
                  <expression localId="1189" locator="627:19-627:31" name="contactPoints" xsi:type="OperandRef"/>
               </source>
               <where localId="1194" locator="627:35-627:56" xsi:type="Equal">
                  <operand localId="1192" locator="627:41-627:45" path="value" xsi:type="Property">
                     <source path="use" scope="P" xsi:type="Property"/>
                  </operand>
                  <operand localId="1193" locator="627:49-627:56" valueType="t:String" value="mobile" xsi:type="Literal"/>
               </where>
            </operand>
         </expression>
         <operand name="contactPoints">
            <operandTypeSpecifier localId="1188" locator="626:38-626:62" xsi:type="ListTypeSpecifier">
               <elementType localId="1187" locator="626:43-626:61" name="fhir:ContactPoint" xsi:type="NamedTypeSpecifier"/>
            </operandTypeSpecifier>
         </operand>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorVersion" : "2.7.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "t" : [ {
            "name" : "author",
            "value" : "Bryn Rhodes"
         }, {
            "name" : "description",
            "value" : "This library defines functions to expose extensions defined\nin QICore as fluent functions in CQL, as well as common terminology and functions\nused in writing CQL with FHIR and QICore profiles."
         } ],
         "s" : {
            "r" : "1197",
            "s" : [ {
               "value" : [ "/*\n@author: Bryn Rhodes\n@description: This library defines functions to expose extensions defined\nin QICore as fluent functions in CQL, as well as common terminology and functions\nused in writing CQL with FHIR and QICore profiles.\n*/\n","library USCoreCommon version '0.1.0'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "USCoreCommon",
         "system" : "http://fhir.org/guides/cqf/us/common",
         "version" : "0.1.0"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "9:1-9:28",
            "localIdentifier" : "USCore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCore" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.1.1'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "2",
            "locator" : "10:1-10:26",
            "localIdentifier" : "FHIR",
            "uri" : "http://hl7.org/fhir",
            "version" : "4.0.1",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "2",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIR" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.0.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "12:1-12:37",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/cqf/us/common/FHIRHelpers",
            "version" : "4.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "3",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.1.000'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "4",
            "locator" : "14:1-14:38",
            "name" : "LOINC",
            "id" : "http://loinc.org",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "4",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"LOINC\"",": ","'http://loinc.org'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "5",
            "locator" : "15:1-15:47",
            "name" : "SNOMEDCT",
            "id" : "http://snomed.info/sct",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "5",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"SNOMEDCT\"",": ","'http://snomed.info/sct'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "6",
            "locator" : "16:1-16:47",
            "name" : "CVX",
            "id" : "http://hl7.org/fhir/sid/cvx",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "6",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"CVX\"",": ","'http://hl7.org/fhir/sid/cvx'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "7",
            "locator" : "17:1-17:72",
            "name" : "ActCode",
            "id" : "http://terminology.hl7.org/CodeSystem/v3-ActCode",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "7",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"ActCode\"",": ","'http://terminology.hl7.org/CodeSystem/v3-ActCode'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "8",
            "locator" : "18:1-18:74",
            "name" : "RoleCode",
            "id" : "http://terminology.hl7.org/CodeSystem/v3-RoleCode",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "8",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"RoleCode\"",": ","'http://terminology.hl7.org/CodeSystem/v3-RoleCode'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "9",
            "locator" : "19:1-19:83",
            "name" : "Diagnosis Role",
            "id" : "http://terminology.hl7.org/CodeSystem/diagnosis-role",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "9",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"Diagnosis Role\"",": ","'http://terminology.hl7.org/CodeSystem/diagnosis-role'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "10",
            "locator" : "20:1-20:64",
            "name" : "RequestIntent",
            "id" : "http://hl7.org/fhir/request-intent",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "10",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"RequestIntent\"",": ","'http://hl7.org/fhir/request-intent'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "11",
            "locator" : "21:1-21:106",
            "name" : "MedicationRequestCategory",
            "id" : "http://terminology.hl7.org/CodeSystem/medicationrequest-category",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "11",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"MedicationRequestCategory\"",": ","'http://terminology.hl7.org/CodeSystem/medicationrequest-category'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "12",
            "locator" : "22:1-22:101",
            "name" : "ConditionClinicalStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/condition-clinical",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "12",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"ConditionClinicalStatusCodes\"",": ","'http://terminology.hl7.org/CodeSystem/condition-clinical'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "13",
            "locator" : "23:1-23:107",
            "name" : "ConditionVerificationStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/condition-ver-status",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "13",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"ConditionVerificationStatusCodes\"",": ","'http://terminology.hl7.org/CodeSystem/condition-ver-status'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "14",
            "locator" : "24:1-24:119",
            "name" : "AllergyIntoleranceClinicalStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "14",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"AllergyIntoleranceClinicalStatusCodes\"",": ","'http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "15",
            "locator" : "25:1-25:127",
            "name" : "AllergyIntoleranceVerificationStatusCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/allergyintolerance-verification",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "15",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"AllergyIntoleranceVerificationStatusCodes\"",": ","'http://terminology.hl7.org/CodeSystem/allergyintolerance-verification'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "16",
            "locator" : "26:1-26:99",
            "name" : "ObservationCategoryCodes",
            "id" : "http://terminology.hl7.org/CodeSystem/observation-category",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "16",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"ObservationCategoryCodes\"",": ","'http://terminology.hl7.org/CodeSystem/observation-category'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "17",
            "locator" : "27:1-27:109",
            "name" : "USCoreObservationCategory",
            "id" : "http://hl7.org/fhir/us/core/CodeSystem/us-core-observation-category",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "17",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"USCoreObservationCategory\"",": ","'http://hl7.org/fhir/us/core/CodeSystem/us-core-observation-category'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "18",
            "locator" : "28:1-28:77",
            "name" : "ObservationStatusCodes",
            "id" : "http://hl7.org/fhir/observation-status",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "18",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"ObservationStatusCodes\"",": ","'http://hl7.org/fhir/observation-status'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "19",
            "locator" : "29:1-29:90",
            "name" : "ConditionCategory",
            "id" : "http://terminology.hl7.org/CodeSystem/condition-category",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "19",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"ConditionCategory\"",": ","'http://terminology.hl7.org/CodeSystem/condition-category'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "20",
            "locator" : "30:1-30:97",
            "name" : "USCoreConditionCategory",
            "id" : "http://hl7.org/fhir/us/core/CodeSystem/condition-category",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "20",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"USCoreConditionCategory\"",": ","'http://hl7.org/fhir/us/core/CodeSystem/condition-category'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "21",
            "locator" : "31:1-31:76",
            "name" : "CDC Race and Ethnicity Codes",
            "id" : "urn:oid:2.16.840.1.113883.6.238",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "21",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"CDC Race and Ethnicity Codes\"",": ","'urn:oid:2.16.840.1.113883.6.238'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "22",
            "locator" : "32:1-32:108",
            "name" : "CommunicationCategoryCodeSystem",
            "id" : "http://terminology.hl7.org/CodeSystem/communication-category",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "22",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"CommunicationCategoryCodeSystem\"",": ","'http://terminology.hl7.org/CodeSystem/communication-category'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "23",
            "locator" : "33:1-33:76",
            "name" : "IdentifierType",
            "id" : "http://terminology.hl7.org/CodeSystem/v2-0203",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "23",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"IdentifierType\"",": ","'http://terminology.hl7.org/CodeSystem/v2-0203'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "25",
            "locator" : "35:1-35:86",
            "name" : "MedicalRecordNumber",
            "id" : "MR",
            "display" : "Medical record number",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "25",
                  "s" : [ {
                     "value" : [ "","code ","\"MedicalRecordNumber\"",": ","'MR'"," from " ]
                  }, {
                     "r" : "24",
                     "s" : [ {
                        "value" : [ "\"IdentifierType\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Medical record number'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "24",
               "locator" : "35:39-35:54",
               "name" : "IdentifierType"
            }
         }, {
            "localId" : "27",
            "locator" : "37:1-37:61",
            "name" : "Birthdate",
            "id" : "21112-8",
            "display" : "Birth date",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "27",
                  "s" : [ {
                     "value" : [ "","code ","\"Birthdate\"",": ","'21112-8'"," from " ]
                  }, {
                     "r" : "26",
                     "s" : [ {
                        "value" : [ "\"LOINC\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Birth date'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "26",
               "locator" : "37:34-37:40",
               "name" : "LOINC"
            }
         }, {
            "localId" : "29",
            "locator" : "38:1-38:55",
            "name" : "Dead",
            "id" : "419099009",
            "display" : "Dead",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "29",
                  "s" : [ {
                     "value" : [ "","code ","\"Dead\"",": ","'419099009'"," from " ]
                  }, {
                     "r" : "28",
                     "s" : [ {
                        "value" : [ "\"SNOMEDCT\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Dead'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "28",
               "locator" : "38:31-38:40",
               "name" : "SNOMEDCT"
            }
         }, {
            "localId" : "31",
            "locator" : "39:1-39:56",
            "name" : "ER",
            "id" : "ER",
            "display" : "Emergency room",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "31",
                  "s" : [ {
                     "value" : [ "","code ","\"ER\"",": ","'ER'"," from " ]
                  }, {
                     "r" : "30",
                     "s" : [ {
                        "value" : [ "\"RoleCode\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Emergency room'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "30",
               "locator" : "39:22-39:31",
               "name" : "RoleCode"
            }
         }, {
            "localId" : "33",
            "locator" : "40:1-40:63",
            "name" : "ICU",
            "id" : "ICU",
            "display" : "Intensive care unit",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "33",
                  "s" : [ {
                     "value" : [ "","code ","\"ICU\"",": ","'ICU'"," from " ]
                  }, {
                     "r" : "32",
                     "s" : [ {
                        "value" : [ "\"RoleCode\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Intensive care unit'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "32",
               "locator" : "40:24-40:33",
               "name" : "RoleCode"
            }
         }, {
            "localId" : "35",
            "locator" : "41:1-41:65",
            "name" : "Billing",
            "id" : "billing",
            "display" : "Billing",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "35",
                  "s" : [ {
                     "value" : [ "","code ","\"Billing\"",": ","'billing'"," from " ]
                  }, {
                     "r" : "34",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Billing'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "34",
               "locator" : "41:32-41:47",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "37",
            "locator" : "44:1-44:58",
            "name" : "ambulatory",
            "id" : "AMB",
            "display" : "ambulatory",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "37",
                  "s" : [ {
                     "value" : [ "// Encounter Class Codes\n","code ","\"ambulatory\"",": ","'AMB'"," from " ]
                  }, {
                     "r" : "36",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'ambulatory'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "36",
               "locator" : "44:31-44:37",
               "name" : "ActCode"
            }
         }, {
            "localId" : "39",
            "locator" : "45:1-45:57",
            "name" : "emergency",
            "id" : "EMER",
            "display" : "emergency",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "39",
                  "s" : [ {
                     "value" : [ "","code ","\"emergency\"",": ","'EMER'"," from " ]
                  }, {
                     "r" : "38",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'emergency'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "38",
               "locator" : "45:31-45:37",
               "name" : "ActCode"
            }
         }, {
            "localId" : "41",
            "locator" : "46:1-46:48",
            "name" : "field",
            "id" : "FLD",
            "display" : "field",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "41",
                  "s" : [ {
                     "value" : [ "","code ","\"field\"",": ","'FLD'"," from " ]
                  }, {
                     "r" : "40",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'field'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "40",
               "locator" : "46:26-46:32",
               "name" : "ActCode"
            }
         }, {
            "localId" : "43",
            "locator" : "47:1-47:59",
            "name" : "home health",
            "id" : "HH",
            "display" : "home health",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "43",
                  "s" : [ {
                     "value" : [ "","code ","\"home health\"",": ","'HH'"," from " ]
                  }, {
                     "r" : "42",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'home health'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "42",
               "locator" : "47:31-47:37",
               "name" : "ActCode"
            }
         }, {
            "localId" : "45",
            "locator" : "48:1-48:76",
            "name" : "inpatient encounter",
            "id" : "IMP",
            "display" : "inpatient encounter",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "45",
                  "s" : [ {
                     "value" : [ "","code ","\"inpatient encounter\"",": ","'IMP'"," from " ]
                  }, {
                     "r" : "44",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'inpatient encounter'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "44",
               "locator" : "48:40-48:46",
               "name" : "ActCode"
            }
         }, {
            "localId" : "47",
            "locator" : "49:1-49:70",
            "name" : "inpatient acute",
            "id" : "ACUTE",
            "display" : "inpatient acute",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "47",
                  "s" : [ {
                     "value" : [ "","code ","\"inpatient acute\"",": ","'ACUTE'"," from " ]
                  }, {
                     "r" : "46",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'inpatient acute'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "46",
               "locator" : "49:38-49:44",
               "name" : "ActCode"
            }
         }, {
            "localId" : "49",
            "locator" : "50:1-50:78",
            "name" : "inpatient non-acute",
            "id" : "NONAC",
            "display" : "inpatient non-acute",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "49",
                  "s" : [ {
                     "value" : [ "","code ","\"inpatient non-acute\"",": ","'NONAC'"," from " ]
                  }, {
                     "r" : "48",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'inpatient non-acute'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "48",
               "locator" : "50:42-50:48",
               "name" : "ActCode"
            }
         }, {
            "localId" : "51",
            "locator" : "51:1-51:83",
            "name" : "observation encounter",
            "id" : "OBSENC",
            "display" : "observation encounter",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "51",
                  "s" : [ {
                     "value" : [ "","code ","\"observation encounter\"",": ","'OBSENC'"," from " ]
                  }, {
                     "r" : "50",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'observation encounter'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "50",
               "locator" : "51:45-51:51",
               "name" : "ActCode"
            }
         }, {
            "localId" : "53",
            "locator" : "52:1-52:66",
            "name" : "pre-admission",
            "id" : "PRENC",
            "display" : "pre-admission",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "53",
                  "s" : [ {
                     "value" : [ "","code ","\"pre-admission\"",": ","'PRENC'"," from " ]
                  }, {
                     "r" : "52",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'pre-admission'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "52",
               "locator" : "52:36-52:42",
               "name" : "ActCode"
            }
         }, {
            "localId" : "55",
            "locator" : "53:1-53:57",
            "name" : "short stay",
            "id" : "SS",
            "display" : "short stay",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "55",
                  "s" : [ {
                     "value" : [ "","code ","\"short stay\"",": ","'SS'"," from " ]
                  }, {
                     "r" : "54",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'short stay'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "54",
               "locator" : "53:30-53:36",
               "name" : "ActCode"
            }
         }, {
            "localId" : "57",
            "locator" : "54:1-54:46",
            "name" : "virtual",
            "id" : "VR",
            "display" : "VR",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "57",
                  "s" : [ {
                     "value" : [ "","code ","\"virtual\"",": ","'VR'"," from " ]
                  }, {
                     "r" : "56",
                     "s" : [ {
                        "value" : [ "ActCode" ]
                     } ]
                  }, {
                     "value" : [ " display ","'VR'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "56",
               "locator" : "54:27-54:33",
               "name" : "ActCode"
            }
         }, {
            "localId" : "59",
            "locator" : "57:1-57:98",
            "name" : "problem-list-item",
            "id" : "problem-list-item",
            "display" : "Problem List Item",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "59",
                  "s" : [ {
                     "value" : [ "// Condition Category Codes\n","code ","\"problem-list-item\"",": ","'problem-list-item'"," from " ]
                  }, {
                     "r" : "58",
                     "s" : [ {
                        "value" : [ "\"ConditionCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Problem List Item'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "58",
               "locator" : "57:52-57:70",
               "name" : "ConditionCategory"
            }
         }, {
            "localId" : "61",
            "locator" : "58:1-58:104",
            "name" : "encounter-diagnosis",
            "id" : "encounter-diagnosis",
            "display" : "Encounter Diagnosis",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "61",
                  "s" : [ {
                     "value" : [ "","code ","\"encounter-diagnosis\"",": ","'encounter-diagnosis'"," from " ]
                  }, {
                     "r" : "60",
                     "s" : [ {
                        "value" : [ "\"ConditionCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Encounter Diagnosis'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "60",
               "locator" : "58:56-58:74",
               "name" : "ConditionCategory"
            }
         }, {
            "localId" : "63",
            "locator" : "59:1-59:95",
            "name" : "health-concern",
            "id" : "health-concern",
            "display" : "Health Concern",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "63",
                  "s" : [ {
                     "value" : [ "","code ","\"health-concern\"",": ","'health-concern'"," from " ]
                  }, {
                     "r" : "62",
                     "s" : [ {
                        "value" : [ "\"USCoreConditionCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Health Concern'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "62",
               "locator" : "59:46-59:70",
               "name" : "USCoreConditionCategory"
            }
         }, {
            "localId" : "65",
            "locator" : "62:1-62:59",
            "name" : "active",
            "id" : "active",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "65",
                  "s" : [ {
                     "value" : [ "// Condition Clinical Status Codes - Consider value sets for these\n","code ","\"active\"",": ","'active'"," from " ]
                  }, {
                     "r" : "64",
                     "s" : [ {
                        "value" : [ "\"ConditionClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "64",
               "locator" : "62:30-62:59",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "67",
            "locator" : "63:1-63:67",
            "name" : "recurrence",
            "id" : "recurrence",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "67",
                  "s" : [ {
                     "value" : [ "","code ","\"recurrence\"",": ","'recurrence'"," from " ]
                  }, {
                     "r" : "66",
                     "s" : [ {
                        "value" : [ "\"ConditionClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "66",
               "locator" : "63:38-63:67",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "69",
            "locator" : "64:1-64:61",
            "name" : "relapse",
            "id" : "relapse",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "69",
                  "s" : [ {
                     "value" : [ "","code ","\"relapse\"",": ","'relapse'"," from " ]
                  }, {
                     "r" : "68",
                     "s" : [ {
                        "value" : [ "\"ConditionClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "68",
               "locator" : "64:32-64:61",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "71",
            "locator" : "65:1-65:63",
            "name" : "inactive",
            "id" : "inactive",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "71",
                  "s" : [ {
                     "value" : [ "","code ","\"inactive\"",": ","'inactive'"," from " ]
                  }, {
                     "r" : "70",
                     "s" : [ {
                        "value" : [ "\"ConditionClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "70",
               "locator" : "65:34-65:63",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "73",
            "locator" : "66:1-66:65",
            "name" : "remission",
            "id" : "remission",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "73",
                  "s" : [ {
                     "value" : [ "","code ","\"remission\"",": ","'remission'"," from " ]
                  }, {
                     "r" : "72",
                     "s" : [ {
                        "value" : [ "\"ConditionClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "72",
               "locator" : "66:36-66:65",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "75",
            "locator" : "67:1-67:63",
            "name" : "resolved",
            "id" : "resolved",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "75",
                  "s" : [ {
                     "value" : [ "","code ","\"resolved\"",": ","'resolved'"," from " ]
                  }, {
                     "r" : "74",
                     "s" : [ {
                        "value" : [ "\"ConditionClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "74",
               "locator" : "67:34-67:63",
               "name" : "ConditionClinicalStatusCodes"
            }
         }, {
            "localId" : "77",
            "locator" : "70:1-70:71",
            "name" : "unconfirmed",
            "id" : "unconfirmed",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "77",
                  "s" : [ {
                     "value" : [ "// Condition Verification Status Codes - Consider value sets for these\n","code ","\"unconfirmed\"",": ","'unconfirmed'"," from " ]
                  }, {
                     "r" : "76",
                     "s" : [ {
                        "value" : [ "ConditionVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "76",
               "locator" : "70:40-70:71",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "79",
            "locator" : "71:1-71:71",
            "name" : "provisional",
            "id" : "provisional",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "79",
                  "s" : [ {
                     "value" : [ "","code ","\"provisional\"",": ","'provisional'"," from " ]
                  }, {
                     "r" : "78",
                     "s" : [ {
                        "value" : [ "ConditionVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "78",
               "locator" : "71:40-71:71",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "81",
            "locator" : "72:1-72:73",
            "name" : "differential",
            "id" : "differential",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "81",
                  "s" : [ {
                     "value" : [ "","code ","\"differential\"",": ","'differential'"," from " ]
                  }, {
                     "r" : "80",
                     "s" : [ {
                        "value" : [ "ConditionVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "80",
               "locator" : "72:42-72:73",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "83",
            "locator" : "73:1-73:67",
            "name" : "confirmed",
            "id" : "confirmed",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "83",
                  "s" : [ {
                     "value" : [ "","code ","\"confirmed\"",": ","'confirmed'"," from " ]
                  }, {
                     "r" : "82",
                     "s" : [ {
                        "value" : [ "ConditionVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "82",
               "locator" : "73:36-73:67",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "85",
            "locator" : "74:1-74:63",
            "name" : "refuted",
            "id" : "refuted",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "85",
                  "s" : [ {
                     "value" : [ "","code ","\"refuted\"",": ","'refuted'"," from " ]
                  }, {
                     "r" : "84",
                     "s" : [ {
                        "value" : [ "ConditionVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "84",
               "locator" : "74:32-74:63",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "87",
            "locator" : "75:1-75:81",
            "name" : "entered-in-error",
            "id" : "entered-in-error",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "87",
                  "s" : [ {
                     "value" : [ "","code ","\"entered-in-error\"",": ","'entered-in-error'"," from " ]
                  }, {
                     "r" : "86",
                     "s" : [ {
                        "value" : [ "ConditionVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "86",
               "locator" : "75:50-75:81",
               "name" : "ConditionVerificationStatusCodes"
            }
         }, {
            "localId" : "89",
            "locator" : "77:1-77:76",
            "name" : "allergy-active",
            "id" : "active",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "89",
                  "s" : [ {
                     "value" : [ "","code ","\"allergy-active\"",": ","'active'"," from " ]
                  }, {
                     "r" : "88",
                     "s" : [ {
                        "value" : [ "\"AllergyIntoleranceClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "88",
               "locator" : "77:38-77:76",
               "name" : "AllergyIntoleranceClinicalStatusCodes"
            }
         }, {
            "localId" : "91",
            "locator" : "78:1-78:80",
            "name" : "allergy-inactive",
            "id" : "inactive",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "91",
                  "s" : [ {
                     "value" : [ "","code ","\"allergy-inactive\"",": ","'inactive'"," from " ]
                  }, {
                     "r" : "90",
                     "s" : [ {
                        "value" : [ "\"AllergyIntoleranceClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "90",
               "locator" : "78:42-78:80",
               "name" : "AllergyIntoleranceClinicalStatusCodes"
            }
         }, {
            "localId" : "93",
            "locator" : "79:1-79:80",
            "name" : "allergy-resolved",
            "id" : "resolved",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "93",
                  "s" : [ {
                     "value" : [ "","code ","\"allergy-resolved\"",": ","'resolved'"," from " ]
                  }, {
                     "r" : "92",
                     "s" : [ {
                        "value" : [ "\"AllergyIntoleranceClinicalStatusCodes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "92",
               "locator" : "79:42-79:80",
               "name" : "AllergyIntoleranceClinicalStatusCodes"
            }
         }, {
            "localId" : "95",
            "locator" : "82:1-82:88",
            "name" : "allergy-unconfirmed",
            "id" : "unconfirmed",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "95",
                  "s" : [ {
                     "value" : [ "// Allergy/Intolerance Verification Status Codes - Consider value sets for these\n","code ","\"allergy-unconfirmed\"",": ","'unconfirmed'"," from " ]
                  }, {
                     "r" : "94",
                     "s" : [ {
                        "value" : [ "AllergyIntoleranceVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "94",
               "locator" : "82:48-82:88",
               "name" : "AllergyIntoleranceVerificationStatusCodes"
            }
         }, {
            "localId" : "97",
            "locator" : "83:1-83:84",
            "name" : "allergy-confirmed",
            "id" : "confirmed",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "97",
                  "s" : [ {
                     "value" : [ "","code ","\"allergy-confirmed\"",": ","'confirmed'"," from " ]
                  }, {
                     "r" : "96",
                     "s" : [ {
                        "value" : [ "AllergyIntoleranceVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "96",
               "locator" : "83:44-83:84",
               "name" : "AllergyIntoleranceVerificationStatusCodes"
            }
         }, {
            "localId" : "99",
            "locator" : "84:1-84:80",
            "name" : "allergy-refuted",
            "id" : "refuted",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "99",
                  "s" : [ {
                     "value" : [ "","code ","\"allergy-refuted\"",": ","'refuted'"," from " ]
                  }, {
                     "r" : "98",
                     "s" : [ {
                        "value" : [ "AllergyIntoleranceVerificationStatusCodes" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "98",
               "locator" : "84:40-84:80",
               "name" : "AllergyIntoleranceVerificationStatusCodes"
            }
         }, {
            "localId" : "101",
            "locator" : "87:1-87:82",
            "name" : "Inpatient",
            "id" : "inpatient",
            "display" : "Inpatient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "101",
                  "s" : [ {
                     "value" : [ "// MedicationRequest Category Codes\n","code ","\"Inpatient\"",": ","'inpatient'"," from " ]
                  }, {
                     "r" : "100",
                     "s" : [ {
                        "value" : [ "\"MedicationRequestCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Inpatient'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "100",
               "locator" : "87:36-87:62",
               "name" : "MedicationRequestCategory"
            }
         }, {
            "localId" : "103",
            "locator" : "88:1-88:85",
            "name" : "Outpatient",
            "id" : "outpatient",
            "display" : "Outpatient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "103",
                  "s" : [ {
                     "value" : [ "","code ","\"Outpatient\"",": ","'outpatient'"," from " ]
                  }, {
                     "r" : "102",
                     "s" : [ {
                        "value" : [ "\"MedicationRequestCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Outpatient'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "102",
               "locator" : "88:38-88:64",
               "name" : "MedicationRequestCategory"
            }
         }, {
            "localId" : "105",
            "locator" : "89:1-89:82",
            "name" : "Community",
            "id" : "community",
            "display" : "Community",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "105",
                  "s" : [ {
                     "value" : [ "","code ","\"Community\"",": ","'community'"," from " ]
                  }, {
                     "r" : "104",
                     "s" : [ {
                        "value" : [ "\"MedicationRequestCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Community'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "104",
               "locator" : "89:36-89:62",
               "name" : "MedicationRequestCategory"
            }
         }, {
            "localId" : "107",
            "locator" : "90:1-90:82",
            "name" : "Discharge",
            "id" : "discharge",
            "display" : "Discharge",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "107",
                  "s" : [ {
                     "value" : [ "","code ","\"Discharge\"",": ","'discharge'"," from " ]
                  }, {
                     "r" : "106",
                     "s" : [ {
                        "value" : [ "\"MedicationRequestCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Discharge'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "106",
               "locator" : "90:36-90:62",
               "name" : "MedicationRequestCategory"
            }
         }, {
            "localId" : "109",
            "locator" : "93:1-93:67",
            "name" : "AD",
            "id" : "AD",
            "display" : "Admission diagnosis",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "109",
                  "s" : [ {
                     "value" : [ "// Diagnosis Role Codes\n","code ","\"AD\"",": ","'AD'"," from " ]
                  }, {
                     "r" : "108",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Admission diagnosis'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "108",
               "locator" : "93:22-93:37",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "111",
            "locator" : "94:1-94:67",
            "name" : "DD",
            "id" : "DD",
            "display" : "Discharge diagnosis",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "111",
                  "s" : [ {
                     "value" : [ "","code ","\"DD\"",": ","'DD'"," from " ]
                  }, {
                     "r" : "110",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Discharge diagnosis'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "110",
               "locator" : "94:22-94:37",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "113",
            "locator" : "95:1-95:63",
            "name" : "CC",
            "id" : "CC",
            "display" : "Chief complaint",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "113",
                  "s" : [ {
                     "value" : [ "","code ","\"CC\"",": ","'CC'"," from " ]
                  }, {
                     "r" : "112",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Chief complaint'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "112",
               "locator" : "95:22-95:37",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "115",
            "locator" : "96:1-96:69",
            "name" : "CM",
            "id" : "CM",
            "display" : "Comorbidity diagnosis",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "115",
                  "s" : [ {
                     "value" : [ "","code ","\"CM\"",": ","'CM'"," from " ]
                  }, {
                     "r" : "114",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Comorbidity diagnosis'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "114",
               "locator" : "96:22-96:37",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "117",
            "locator" : "97:1-97:72",
            "name" : "pre-op",
            "id" : "pre-op",
            "display" : "pre-op diagnosis",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "117",
                  "s" : [ {
                     "value" : [ "","code ","\"pre-op\"",": ","'pre-op'"," from " ]
                  }, {
                     "r" : "116",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'pre-op diagnosis'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "116",
               "locator" : "97:30-97:45",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "119",
            "locator" : "98:1-98:75",
            "name" : "post-op",
            "id" : "post-op",
            "display" : "post-op diagnosis",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "119",
                  "s" : [ {
                     "value" : [ "","code ","\"post-op\"",": ","'post-op'"," from " ]
                  }, {
                     "r" : "118",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'post-op diagnosis'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "118",
               "locator" : "98:32-98:47",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "121",
            "locator" : "99:1-99:75",
            "name" : "billing",
            "id" : "billing",
            "display" : "billing diagnosis",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "121",
                  "s" : [ {
                     "value" : [ "","code ","\"billing\"",": ","'billing'"," from " ]
                  }, {
                     "r" : "120",
                     "s" : [ {
                        "value" : [ "\"Diagnosis Role\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'billing diagnosis'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "120",
               "locator" : "99:32-99:47",
               "name" : "Diagnosis Role"
            }
         }, {
            "localId" : "123",
            "locator" : "102:1-102:96",
            "name" : "social-history",
            "id" : "social-history",
            "display" : "Social History",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "123",
                  "s" : [ {
                     "value" : [ "// Observation Category Codes\n","code ","\"social-history\"",": ","'social-history'"," from " ]
                  }, {
                     "r" : "122",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Social History'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "122",
               "locator" : "102:46-102:71",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "125",
            "locator" : "103:1-103:87",
            "name" : "vital-signs",
            "id" : "vital-signs",
            "display" : "Vital Signs",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "125",
                  "s" : [ {
                     "value" : [ "","code ","\"vital-signs\"",": ","'vital-signs'"," from " ]
                  }, {
                     "r" : "124",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Vital Signs'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "124",
               "locator" : "103:40-103:65",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "127",
            "locator" : "104:1-104:75",
            "name" : "imaging",
            "id" : "imaging",
            "display" : "Imaging",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "127",
                  "s" : [ {
                     "value" : [ "","code ","\"imaging\"",": ","'imaging'"," from " ]
                  }, {
                     "r" : "126",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Imaging'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "126",
               "locator" : "104:32-104:57",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "129",
            "locator" : "105:1-105:84",
            "name" : "laboratory",
            "id" : "laboratory",
            "display" : "Laboratory",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "129",
                  "s" : [ {
                     "value" : [ "","code ","\"laboratory\"",": ","'laboratory'"," from " ]
                  }, {
                     "r" : "128",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Laboratory'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "128",
               "locator" : "105:38-105:63",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "131",
            "locator" : "106:1-106:81",
            "name" : "procedure",
            "id" : "procedure",
            "display" : "Procedure",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "131",
                  "s" : [ {
                     "value" : [ "","code ","\"procedure\"",": ","'procedure'"," from " ]
                  }, {
                     "r" : "130",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Procedure'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "130",
               "locator" : "106:36-106:61",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "133",
            "locator" : "107:1-107:72",
            "name" : "survey",
            "id" : "survey",
            "display" : "Survey",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "133",
                  "s" : [ {
                     "value" : [ "","code ","\"survey\"",": ","'survey'"," from " ]
                  }, {
                     "r" : "132",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Survey'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "132",
               "locator" : "107:30-107:55",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "135",
            "locator" : "108:1-108:66",
            "name" : "exam",
            "id" : "exam",
            "display" : "Exam",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "135",
                  "s" : [ {
                     "value" : [ "","code ","\"exam\"",": ","'exam'"," from " ]
                  }, {
                     "r" : "134",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Exam'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "134",
               "locator" : "108:26-108:51",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "137",
            "locator" : "109:1-109:75",
            "name" : "therapy",
            "id" : "therapy",
            "display" : "Therapy",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "137",
                  "s" : [ {
                     "value" : [ "","code ","\"therapy\"",": ","'therapy'"," from " ]
                  }, {
                     "r" : "136",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Therapy'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "136",
               "locator" : "109:32-109:57",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "139",
            "locator" : "110:1-110:78",
            "name" : "activity",
            "id" : "activity",
            "display" : "Activity",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "139",
                  "s" : [ {
                     "value" : [ "","code ","\"activity\"",": ","'activity'"," from " ]
                  }, {
                     "r" : "138",
                     "s" : [ {
                        "value" : [ "\"ObservationCategoryCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Activity'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "138",
               "locator" : "110:34-110:59",
               "name" : "ObservationCategoryCodes"
            }
         }, {
            "localId" : "141",
            "locator" : "111:1-111:94",
            "name" : "clinical-test",
            "id" : "clinical-test",
            "display" : "Clinical Test",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "141",
                  "s" : [ {
                     "value" : [ "","code ","\"clinical-test\"",": ","'clinical-test'"," from " ]
                  }, {
                     "r" : "140",
                     "s" : [ {
                        "value" : [ "\"USCoreObservationCategory\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Clinical Test'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "140",
               "locator" : "111:44-111:70",
               "name" : "USCoreObservationCategory"
            }
         }, {
            "localId" : "143",
            "locator" : "114:1-114:94",
            "name" : "observation-registered",
            "id" : "registered",
            "display" : "Registered",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "143",
                  "s" : [ {
                     "value" : [ "// Observation Status Codes\n","code ","\"observation-registered\"",": ","'registered'"," from " ]
                  }, {
                     "r" : "142",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Registered'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "142",
               "locator" : "114:50-114:73",
               "name" : "ObservationStatusCodes"
            }
         }, {
            "localId" : "145",
            "locator" : "115:1-115:97",
            "name" : "observation-preliminary",
            "id" : "preliminary",
            "display" : "Preliminary",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "145",
                  "s" : [ {
                     "value" : [ "","code ","\"observation-preliminary\"",": ","'preliminary'"," from " ]
                  }, {
                     "r" : "144",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Preliminary'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "144",
               "locator" : "115:52-115:75",
               "name" : "ObservationStatusCodes"
            }
         }, {
            "localId" : "147",
            "locator" : "116:1-116:79",
            "name" : "observation-final",
            "id" : "final",
            "display" : "Final",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "147",
                  "s" : [ {
                     "value" : [ "","code ","\"observation-final\"",": ","'final'"," from " ]
                  }, {
                     "r" : "146",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Final'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "146",
               "locator" : "116:40-116:63",
               "name" : "ObservationStatusCodes"
            }
         }, {
            "localId" : "149",
            "locator" : "117:1-117:85",
            "name" : "observation-amended",
            "id" : "amended",
            "display" : "Amended",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "149",
                  "s" : [ {
                     "value" : [ "","code ","\"observation-amended\"",": ","'amended'"," from " ]
                  }, {
                     "r" : "148",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Amended'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "148",
               "locator" : "117:44-117:67",
               "name" : "ObservationStatusCodes"
            }
         }, {
            "localId" : "151",
            "locator" : "118:1-118:91",
            "name" : "observation-corrected",
            "id" : "corrected",
            "display" : "Corrected",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "151",
                  "s" : [ {
                     "value" : [ "","code ","\"observation-corrected\"",": ","'corrected'"," from " ]
                  }, {
                     "r" : "150",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Corrected'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "150",
               "locator" : "118:48-118:71",
               "name" : "ObservationStatusCodes"
            }
         }, {
            "localId" : "153",
            "locator" : "119:1-119:91",
            "name" : "observation-cancelled",
            "id" : "cancelled",
            "display" : "Cancelled",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "153",
                  "s" : [ {
                     "value" : [ "","code ","\"observation-cancelled\"",": ","'cancelled'"," from " ]
                  }, {
                     "r" : "152",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Cancelled'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "152",
               "locator" : "119:48-119:71",
               "name" : "ObservationStatusCodes"
            }
         }, {
            "localId" : "155",
            "locator" : "120:1-120:112",
            "name" : "observation-entered-in-error",
            "id" : "entered-in-error",
            "display" : "Entered in Error",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "155",
                  "s" : [ {
                     "value" : [ "","code ","\"observation-entered-in-error\"",": ","'entered-in-error'"," from " ]
                  }, {
                     "r" : "154",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Entered in Error'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "154",
               "locator" : "120:62-120:85",
               "name" : "ObservationStatusCodes"
            }
         }, {
            "localId" : "157",
            "locator" : "121:1-121:85",
            "name" : "observation-unknown",
            "id" : "unknown",
            "display" : "Unknown",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "157",
                  "s" : [ {
                     "value" : [ "","code ","\"observation-unknown\"",": ","'unknown'"," from " ]
                  }, {
                     "r" : "156",
                     "s" : [ {
                        "value" : [ "\"ObservationStatusCodes\"" ]
                     } ]
                  }, {
                     "value" : [ " display ","'Unknown'" ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "156",
               "locator" : "121:44-121:67",
               "name" : "ObservationStatusCodes"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "locator" : "123:1-123:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "123:1-123:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "123:1-123:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "173",
            "locator" : "130:1-133:43",
            "name" : "isActive",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given condition has a clinical status of active, recurrence, or relapse"
               } ],
               "s" : {
                  "r" : "173",
                  "s" : [ {
                     "value" : [ "/* Candidates for FHIRCommon */\n\n/*\n@description: Returns true if the given condition has a clinical status of active, recurrence, or relapse\n*/\n","define fluent function ","isActive","(","condition"," " ]
                  }, {
                     "r" : "158",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "172",
                     "s" : [ {
                        "r" : "172",
                        "s" : [ {
                           "r" : "167",
                           "s" : [ {
                              "r" : "162",
                              "s" : [ {
                                 "r" : "160",
                                 "s" : [ {
                                    "r" : "159",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "160",
                                    "s" : [ {
                                       "value" : [ "clinicalStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "161",
                                 "s" : [ {
                                    "value" : [ "\"active\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    or " ]
                           }, {
                              "r" : "166",
                              "s" : [ {
                                 "r" : "164",
                                 "s" : [ {
                                    "r" : "163",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "164",
                                    "s" : [ {
                                       "value" : [ "clinicalStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "165",
                                 "s" : [ {
                                    "value" : [ "\"recurrence\"" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "171",
                           "s" : [ {
                              "r" : "169",
                              "s" : [ {
                                 "r" : "168",
                                 "s" : [ {
                                    "value" : [ "condition" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "169",
                                 "s" : [ {
                                    "value" : [ "clinicalStatus" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","~"," " ]
                           }, {
                              "r" : "170",
                              "s" : [ {
                                 "value" : [ "\"relapse\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "172",
               "locator" : "131:3-133:43",
               "type" : "Or",
               "operand" : [ {
                  "localId" : "167",
                  "locator" : "131:3-132:46",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "162",
                     "locator" : "131:3-131:37",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "160",
                        "locator" : "131:3-131:26",
                        "name" : "ToConcept",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "clinicalStatus",
                           "type" : "Property",
                           "source" : {
                              "localId" : "159",
                              "locator" : "131:3-131:11",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        } ]
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "161",
                           "locator" : "131:30-131:37",
                           "name" : "active",
                           "type" : "CodeRef"
                        }
                     } ]
                  }, {
                     "localId" : "166",
                     "locator" : "132:8-132:46",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "164",
                        "locator" : "132:8-132:31",
                        "name" : "ToConcept",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "clinicalStatus",
                           "type" : "Property",
                           "source" : {
                              "localId" : "163",
                              "locator" : "132:8-132:16",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        } ]
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "165",
                           "locator" : "132:35-132:46",
                           "name" : "recurrence",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }, {
                  "localId" : "171",
                  "locator" : "133:8-133:43",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "169",
                     "locator" : "133:8-133:31",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "clinicalStatus",
                        "type" : "Property",
                        "source" : {
                           "localId" : "168",
                           "locator" : "133:8-133:16",
                           "name" : "condition",
                           "type" : "OperandRef"
                        }
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "170",
                        "locator" : "133:35-133:43",
                        "name" : "relapse",
                        "type" : "CodeRef"
                     }
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "158",
                  "locator" : "130:43-130:58",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "193",
            "locator" : "135:1-139:37",
            "name" : "active",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "193",
                  "s" : [ {
                     "value" : [ "","define fluent function ","active","(","conditions"," " ]
                  }, {
                     "r" : "175",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "174",
                        "s" : [ {
                           "value" : [ "USCore",".","Condition" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "192",
                     "s" : [ {
                        "r" : "192",
                        "s" : [ {
                           "s" : [ {
                              "r" : "177",
                              "s" : [ {
                                 "r" : "176",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "conditions" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","C" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "191",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "191",
                              "s" : [ {
                                 "r" : "186",
                                 "s" : [ {
                                    "r" : "181",
                                    "s" : [ {
                                       "r" : "179",
                                       "s" : [ {
                                          "r" : "178",
                                          "s" : [ {
                                             "value" : [ "C" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "179",
                                          "s" : [ {
                                             "value" : [ "clinicalStatus" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "180",
                                       "s" : [ {
                                          "value" : [ "\"active\"" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n      or " ]
                                 }, {
                                    "r" : "185",
                                    "s" : [ {
                                       "r" : "183",
                                       "s" : [ {
                                          "r" : "182",
                                          "s" : [ {
                                             "value" : [ "C" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "183",
                                          "s" : [ {
                                             "value" : [ "clinicalStatus" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "184",
                                       "s" : [ {
                                          "value" : [ "\"recurrence\"" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      or " ]
                              }, {
                                 "r" : "190",
                                 "s" : [ {
                                    "r" : "188",
                                    "s" : [ {
                                       "r" : "187",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "188",
                                       "s" : [ {
                                          "value" : [ "clinicalStatus" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "189",
                                    "s" : [ {
                                       "value" : [ "\"relapse\"" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "192",
               "locator" : "136:3-139:37",
               "type" : "Query",
               "source" : [ {
                  "localId" : "177",
                  "locator" : "136:3-136:14",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "176",
                     "locator" : "136:3-136:12",
                     "name" : "conditions",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "191",
                  "locator" : "137:5-139:37",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "186",
                     "locator" : "137:11-138:40",
                     "type" : "Or",
                     "operand" : [ {
                        "localId" : "181",
                        "locator" : "137:11-137:37",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "179",
                           "locator" : "137:11-137:26",
                           "name" : "ToConcept",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "clinicalStatus",
                              "scope" : "C",
                              "type" : "Property"
                           } ]
                        }, {
                           "type" : "ToConcept",
                           "operand" : {
                              "localId" : "180",
                              "locator" : "137:30-137:37",
                              "name" : "active",
                              "type" : "CodeRef"
                           }
                        } ]
                     }, {
                        "localId" : "185",
                        "locator" : "138:10-138:40",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "183",
                           "locator" : "138:10-138:25",
                           "name" : "ToConcept",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "clinicalStatus",
                              "scope" : "C",
                              "type" : "Property"
                           } ]
                        }, {
                           "type" : "ToConcept",
                           "operand" : {
                              "localId" : "184",
                              "locator" : "138:29-138:40",
                              "name" : "recurrence",
                              "type" : "CodeRef"
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "190",
                     "locator" : "139:10-139:37",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "188",
                        "locator" : "139:10-139:25",
                        "name" : "ToConcept",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "clinicalStatus",
                           "scope" : "C",
                           "type" : "Property"
                        } ]
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "189",
                           "locator" : "139:29-139:37",
                           "name" : "relapse",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }
            },
            "operand" : [ {
               "name" : "conditions",
               "operandTypeSpecifier" : {
                  "localId" : "175",
                  "locator" : "135:42-135:63",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "174",
                     "locator" : "135:47-135:62",
                     "name" : "{http://hl7.org/fhir}Condition",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "199",
            "locator" : "141:1-142:54",
            "name" : "isAllergyActive",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "199",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAllergyActive","(","allergyIntolerance"," " ]
                  }, {
                     "r" : "194",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "198",
                     "s" : [ {
                        "r" : "198",
                        "s" : [ {
                           "r" : "196",
                           "s" : [ {
                              "r" : "195",
                              "s" : [ {
                                 "value" : [ "allergyIntolerance" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "196",
                              "s" : [ {
                                 "value" : [ "clinicalStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "197",
                           "s" : [ {
                              "value" : [ "\"allergy-active\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "198",
               "locator" : "142:3-142:54",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "196",
                  "locator" : "142:3-142:35",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "clinicalStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "195",
                        "locator" : "142:3-142:20",
                        "name" : "allergyIntolerance",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "197",
                     "locator" : "142:39-142:54",
                     "name" : "allergy-active",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "allergyIntolerance",
               "operandTypeSpecifier" : {
                  "localId" : "194",
                  "locator" : "141:59-141:83",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "209",
            "locator" : "144:1-146:45",
            "name" : "allergyActive",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "209",
                  "s" : [ {
                     "value" : [ "","define fluent function ","allergyActive","(","allergyIntolerances"," " ]
                  }, {
                     "r" : "201",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "200",
                        "s" : [ {
                           "value" : [ "USCore",".","AllergyIntolerance" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "208",
                     "s" : [ {
                        "r" : "208",
                        "s" : [ {
                           "s" : [ {
                              "r" : "203",
                              "s" : [ {
                                 "r" : "202",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "allergyIntolerances" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","A" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "207",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "207",
                              "s" : [ {
                                 "r" : "205",
                                 "s" : [ {
                                    "r" : "204",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "205",
                                    "s" : [ {
                                       "value" : [ "clinicalStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "206",
                                 "s" : [ {
                                    "value" : [ "\"allergy-active\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "208",
               "locator" : "145:3-146:45",
               "type" : "Query",
               "source" : [ {
                  "localId" : "203",
                  "locator" : "145:3-145:23",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "202",
                     "locator" : "145:3-145:21",
                     "name" : "allergyIntolerances",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "207",
                  "locator" : "146:5-146:45",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "205",
                     "locator" : "146:11-146:26",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "clinicalStatus",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "206",
                        "locator" : "146:30-146:45",
                        "name" : "allergy-active",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "allergyIntolerances",
               "operandTypeSpecifier" : {
                  "localId" : "201",
                  "locator" : "144:58-144:88",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "200",
                     "locator" : "144:63-144:87",
                     "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "215",
            "locator" : "148:1-149:56",
            "name" : "isAllergyInactive",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "215",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAllergyInactive","(","allergyIntolerance"," " ]
                  }, {
                     "r" : "210",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "214",
                     "s" : [ {
                        "r" : "214",
                        "s" : [ {
                           "r" : "212",
                           "s" : [ {
                              "r" : "211",
                              "s" : [ {
                                 "value" : [ "allergyIntolerance" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "212",
                              "s" : [ {
                                 "value" : [ "clinicalStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "213",
                           "s" : [ {
                              "value" : [ "\"allergy-inactive\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "214",
               "locator" : "149:3-149:56",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "212",
                  "locator" : "149:3-149:35",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "clinicalStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "211",
                        "locator" : "149:3-149:20",
                        "name" : "allergyIntolerance",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "213",
                     "locator" : "149:39-149:56",
                     "name" : "allergy-inactive",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "allergyIntolerance",
               "operandTypeSpecifier" : {
                  "localId" : "210",
                  "locator" : "148:61-148:85",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "225",
            "locator" : "151:1-153:47",
            "name" : "allergyInactive",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "225",
                  "s" : [ {
                     "value" : [ "","define fluent function ","allergyInactive","(","allergyIntolerances"," " ]
                  }, {
                     "r" : "217",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "216",
                        "s" : [ {
                           "value" : [ "USCore",".","AllergyIntolerance" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "224",
                     "s" : [ {
                        "r" : "224",
                        "s" : [ {
                           "s" : [ {
                              "r" : "219",
                              "s" : [ {
                                 "r" : "218",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "allergyIntolerances" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","A" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "223",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "223",
                              "s" : [ {
                                 "r" : "221",
                                 "s" : [ {
                                    "r" : "220",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "221",
                                    "s" : [ {
                                       "value" : [ "clinicalStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "222",
                                 "s" : [ {
                                    "value" : [ "\"allergy-inactive\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "224",
               "locator" : "152:3-153:47",
               "type" : "Query",
               "source" : [ {
                  "localId" : "219",
                  "locator" : "152:3-152:23",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "218",
                     "locator" : "152:3-152:21",
                     "name" : "allergyIntolerances",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "223",
                  "locator" : "153:5-153:47",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "221",
                     "locator" : "153:11-153:26",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "clinicalStatus",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "222",
                        "locator" : "153:30-153:47",
                        "name" : "allergy-inactive",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "allergyIntolerances",
               "operandTypeSpecifier" : {
                  "localId" : "217",
                  "locator" : "151:60-151:90",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "216",
                     "locator" : "151:65-151:89",
                     "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "231",
            "locator" : "155:1-156:56",
            "name" : "isAllergyResolved",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "231",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAllergyResolved","(","allergyIntolerance"," " ]
                  }, {
                     "r" : "226",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "230",
                     "s" : [ {
                        "r" : "230",
                        "s" : [ {
                           "r" : "228",
                           "s" : [ {
                              "r" : "227",
                              "s" : [ {
                                 "value" : [ "allergyIntolerance" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "228",
                              "s" : [ {
                                 "value" : [ "clinicalStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "229",
                           "s" : [ {
                              "value" : [ "\"allergy-resolved\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "230",
               "locator" : "156:3-156:56",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "228",
                  "locator" : "156:3-156:35",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "clinicalStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "227",
                        "locator" : "156:3-156:20",
                        "name" : "allergyIntolerance",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "229",
                     "locator" : "156:39-156:56",
                     "name" : "allergy-resolved",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "allergyIntolerance",
               "operandTypeSpecifier" : {
                  "localId" : "226",
                  "locator" : "155:61-155:85",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "241",
            "locator" : "158:1-160:47",
            "name" : "allergyResolved",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "241",
                  "s" : [ {
                     "value" : [ "","define fluent function ","allergyResolved","(","allergyIntolerances"," " ]
                  }, {
                     "r" : "233",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "232",
                        "s" : [ {
                           "value" : [ "USCore",".","AllergyIntolerance" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "240",
                     "s" : [ {
                        "r" : "240",
                        "s" : [ {
                           "s" : [ {
                              "r" : "235",
                              "s" : [ {
                                 "r" : "234",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "allergyIntolerances" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","A" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "239",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "239",
                              "s" : [ {
                                 "r" : "237",
                                 "s" : [ {
                                    "r" : "236",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "237",
                                    "s" : [ {
                                       "value" : [ "clinicalStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "238",
                                 "s" : [ {
                                    "value" : [ "\"allergy-resolved\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "240",
               "locator" : "159:3-160:47",
               "type" : "Query",
               "source" : [ {
                  "localId" : "235",
                  "locator" : "159:3-159:23",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "234",
                     "locator" : "159:3-159:21",
                     "name" : "allergyIntolerances",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "239",
                  "locator" : "160:5-160:47",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "237",
                     "locator" : "160:11-160:26",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "clinicalStatus",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "238",
                        "locator" : "160:30-160:47",
                        "name" : "allergy-resolved",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "allergyIntolerances",
               "operandTypeSpecifier" : {
                  "localId" : "233",
                  "locator" : "158:60-158:90",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "232",
                     "locator" : "158:65-158:89",
                     "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "247",
            "locator" : "162:1-163:61",
            "name" : "isAllergyConfirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "247",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAllergyConfirmed","(","allergyIntolerance"," " ]
                  }, {
                     "r" : "242",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "246",
                     "s" : [ {
                        "r" : "246",
                        "s" : [ {
                           "r" : "244",
                           "s" : [ {
                              "r" : "243",
                              "s" : [ {
                                 "value" : [ "allergyIntolerance" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "244",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "245",
                           "s" : [ {
                              "value" : [ "\"allergy-confirmed\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "246",
               "locator" : "163:3-163:61",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "244",
                  "locator" : "163:3-163:39",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "243",
                        "locator" : "163:3-163:20",
                        "name" : "allergyIntolerance",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "245",
                     "locator" : "163:43-163:61",
                     "name" : "allergy-confirmed",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "allergyIntolerance",
               "operandTypeSpecifier" : {
                  "localId" : "242",
                  "locator" : "162:62-162:86",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "257",
            "locator" : "165:1-167:52",
            "name" : "allergyConfirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "257",
                  "s" : [ {
                     "value" : [ "","define fluent function ","allergyConfirmed","(","allergyIntolerances"," " ]
                  }, {
                     "r" : "249",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "248",
                        "s" : [ {
                           "value" : [ "USCore",".","AllergyIntolerance" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "256",
                     "s" : [ {
                        "r" : "256",
                        "s" : [ {
                           "s" : [ {
                              "r" : "251",
                              "s" : [ {
                                 "r" : "250",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "allergyIntolerances" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","A" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "255",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "255",
                              "s" : [ {
                                 "r" : "253",
                                 "s" : [ {
                                    "r" : "252",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "253",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "254",
                                 "s" : [ {
                                    "value" : [ "\"allergy-confirmed\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "256",
               "locator" : "166:3-167:52",
               "type" : "Query",
               "source" : [ {
                  "localId" : "251",
                  "locator" : "166:3-166:23",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "250",
                     "locator" : "166:3-166:21",
                     "name" : "allergyIntolerances",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "255",
                  "locator" : "167:5-167:52",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "253",
                     "locator" : "167:11-167:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "254",
                        "locator" : "167:34-167:52",
                        "name" : "allergy-confirmed",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "allergyIntolerances",
               "operandTypeSpecifier" : {
                  "localId" : "249",
                  "locator" : "165:61-165:91",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "248",
                     "locator" : "165:66-165:90",
                     "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "263",
            "locator" : "169:1-170:63",
            "name" : "isAllergyUnconfirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "263",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAllergyUnconfirmed","(","allergyIntolerance"," " ]
                  }, {
                     "r" : "258",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "262",
                     "s" : [ {
                        "r" : "262",
                        "s" : [ {
                           "r" : "260",
                           "s" : [ {
                              "r" : "259",
                              "s" : [ {
                                 "value" : [ "allergyIntolerance" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "260",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "261",
                           "s" : [ {
                              "value" : [ "\"allergy-unconfirmed\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "262",
               "locator" : "170:3-170:63",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "260",
                  "locator" : "170:3-170:39",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "259",
                        "locator" : "170:3-170:20",
                        "name" : "allergyIntolerance",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "261",
                     "locator" : "170:43-170:63",
                     "name" : "allergy-unconfirmed",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "allergyIntolerance",
               "operandTypeSpecifier" : {
                  "localId" : "258",
                  "locator" : "169:64-169:88",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "272",
            "locator" : "172:1-174:54",
            "name" : "allergyUnconfirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "272",
                  "s" : [ {
                     "value" : [ "","define fluent function ","allergyUnconfirmed","(","allergyIntolerances"," " ]
                  }, {
                     "r" : "264",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "271",
                     "s" : [ {
                        "r" : "271",
                        "s" : [ {
                           "s" : [ {
                              "r" : "266",
                              "s" : [ {
                                 "r" : "265",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "allergyIntolerances" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","A" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "270",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "270",
                              "s" : [ {
                                 "r" : "268",
                                 "s" : [ {
                                    "r" : "267",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "268",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "269",
                                 "s" : [ {
                                    "value" : [ "\"allergy-unconfirmed\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "271",
               "locator" : "173:3-174:54",
               "type" : "Query",
               "source" : [ {
                  "localId" : "266",
                  "locator" : "173:3-173:23",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "265",
                     "locator" : "173:3-173:21",
                     "name" : "allergyIntolerances",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "270",
                  "locator" : "174:5-174:54",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "268",
                     "locator" : "174:11-174:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "269",
                        "locator" : "174:34-174:54",
                        "name" : "allergy-unconfirmed",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "allergyIntolerances",
               "operandTypeSpecifier" : {
                  "localId" : "264",
                  "locator" : "172:63-172:87",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "278",
            "locator" : "176:1-177:59",
            "name" : "isAllergyRefuted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "278",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAllergyRefuted","(","allergyIntolerance"," " ]
                  }, {
                     "r" : "273",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "277",
                     "s" : [ {
                        "r" : "277",
                        "s" : [ {
                           "r" : "275",
                           "s" : [ {
                              "r" : "274",
                              "s" : [ {
                                 "value" : [ "allergyIntolerance" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "275",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "276",
                           "s" : [ {
                              "value" : [ "\"allergy-refuted\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "277",
               "locator" : "177:3-177:59",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "275",
                  "locator" : "177:3-177:39",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "274",
                        "locator" : "177:3-177:20",
                        "name" : "allergyIntolerance",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "276",
                     "locator" : "177:43-177:59",
                     "name" : "allergy-refuted",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "allergyIntolerance",
               "operandTypeSpecifier" : {
                  "localId" : "273",
                  "locator" : "176:60-176:84",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "287",
            "locator" : "179:1-181:50",
            "name" : "allergyRefuted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "287",
                  "s" : [ {
                     "value" : [ "","define fluent function ","allergyRefuted","(","allergyIntolerances"," " ]
                  }, {
                     "r" : "279",
                     "s" : [ {
                        "value" : [ "USCore",".","AllergyIntolerance" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "286",
                     "s" : [ {
                        "r" : "286",
                        "s" : [ {
                           "s" : [ {
                              "r" : "281",
                              "s" : [ {
                                 "r" : "280",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "allergyIntolerances" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","A" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "285",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "285",
                              "s" : [ {
                                 "r" : "283",
                                 "s" : [ {
                                    "r" : "282",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "283",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "284",
                                 "s" : [ {
                                    "value" : [ "\"allergy-refuted\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "286",
               "locator" : "180:3-181:50",
               "type" : "Query",
               "source" : [ {
                  "localId" : "281",
                  "locator" : "180:3-180:23",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "280",
                     "locator" : "180:3-180:21",
                     "name" : "allergyIntolerances",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "285",
                  "locator" : "181:5-181:50",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "283",
                     "locator" : "181:11-181:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "284",
                        "locator" : "181:34-181:50",
                        "name" : "allergy-refuted",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "allergyIntolerances",
               "operandTypeSpecifier" : {
                  "localId" : "279",
                  "locator" : "179:59-179:83",
                  "name" : "{http://hl7.org/fhir}AllergyIntolerance",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "297",
            "locator" : "186:1-189:3",
            "name" : "hasCategory",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given condition has the given category"
               } ],
               "s" : {
                  "r" : "297",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given condition has the given category\n*/\n","define fluent function ","hasCategory","(","condition"," " ]
                  }, {
                     "r" : "288",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ ", ","category"," " ]
                  }, {
                     "r" : "289",
                     "s" : [ {
                        "value" : [ "Code" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "296",
                     "s" : [ {
                        "r" : "296",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "295",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "295",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "291",
                                    "s" : [ {
                                       "r" : "290",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "condition",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "294",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "294",
                                    "s" : [ {
                                       "r" : "292",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "293",
                                       "s" : [ {
                                          "value" : [ "category" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "296",
               "locator" : "187:3-189:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "295",
                  "locator" : "187:10-189:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "291",
                     "locator" : "187:11-187:30",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "290",
                        "locator" : "187:11-187:28",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "condition",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "294",
                     "locator" : "188:5-188:22",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "292",
                        "locator" : "188:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "293",
                           "locator" : "188:15-188:22",
                           "name" : "category",
                           "type" : "OperandRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "288",
                  "locator" : "186:46-186:61",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "category",
               "operandTypeSpecifier" : {
                  "localId" : "289",
                  "locator" : "186:73-186:76",
                  "name" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "306",
            "locator" : "194:1-197:3",
            "name" : "isProblemListItem",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given condition is a problem list item."
               } ],
               "s" : {
                  "r" : "306",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given condition is a problem list item.\n*/\n","define fluent function ","isProblemListItem","(","condition"," " ]
                  }, {
                     "r" : "298",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "305",
                     "s" : [ {
                        "r" : "305",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "304",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "304",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "300",
                                    "s" : [ {
                                       "r" : "299",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "condition",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "303",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "303",
                                    "s" : [ {
                                       "r" : "301",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "302",
                                       "s" : [ {
                                          "value" : [ "\"problem-list-item\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "305",
               "locator" : "195:3-197:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "304",
                  "locator" : "195:10-197:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "300",
                     "locator" : "195:11-195:30",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "299",
                        "locator" : "195:11-195:28",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "condition",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "303",
                     "locator" : "196:5-196:33",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "301",
                        "locator" : "196:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "302",
                           "locator" : "196:15-196:33",
                           "name" : "problem-list-item",
                           "type" : "CodeRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "298",
                  "locator" : "194:52-194:67",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "315",
            "locator" : "202:1-205:3",
            "name" : "isEncounterDiagnosis",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given condition is an encounter diagnosis"
               } ],
               "s" : {
                  "r" : "315",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given condition is an encounter diagnosis\n*/\n","define fluent function ","isEncounterDiagnosis","(","condition"," " ]
                  }, {
                     "r" : "307",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "314",
                     "s" : [ {
                        "r" : "314",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "313",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "313",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "309",
                                    "s" : [ {
                                       "r" : "308",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "condition",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "312",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "312",
                                    "s" : [ {
                                       "r" : "310",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "311",
                                       "s" : [ {
                                          "value" : [ "\"encounter-diagnosis\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "314",
               "locator" : "203:3-205:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "313",
                  "locator" : "203:10-205:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "309",
                     "locator" : "203:11-203:30",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "308",
                        "locator" : "203:11-203:28",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "condition",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "312",
                     "locator" : "204:5-204:35",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "310",
                        "locator" : "204:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "311",
                           "locator" : "204:15-204:35",
                           "name" : "encounter-diagnosis",
                           "type" : "CodeRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "307",
                  "locator" : "202:55-202:70",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "324",
            "locator" : "210:1-213:3",
            "name" : "isHealthConcern",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given condition is a health concern"
               } ],
               "s" : {
                  "r" : "324",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given condition is a health concern\n*/\n","define fluent function ","isHealthConcern","(","condition"," " ]
                  }, {
                     "r" : "316",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "323",
                     "s" : [ {
                        "r" : "323",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "322",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "322",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "318",
                                    "s" : [ {
                                       "r" : "317",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "condition",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "321",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "321",
                                    "s" : [ {
                                       "r" : "319",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "320",
                                       "s" : [ {
                                          "value" : [ "\"health-concern\"" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "323",
               "locator" : "211:3-213:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "322",
                  "locator" : "211:10-213:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "318",
                     "locator" : "211:11-211:30",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "317",
                        "locator" : "211:11-211:28",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "condition",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "321",
                     "locator" : "212:5-212:30",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "319",
                        "locator" : "212:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "320",
                           "locator" : "212:15-212:30",
                           "name" : "health-concern",
                           "type" : "CodeRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "316",
                  "locator" : "210:50-210:65",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "330",
            "locator" : "215:1-216:46",
            "name" : "isUnconfirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "330",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isUnconfirmed","(","condition"," " ]
                  }, {
                     "r" : "325",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "329",
                     "s" : [ {
                        "r" : "329",
                        "s" : [ {
                           "r" : "327",
                           "s" : [ {
                              "r" : "326",
                              "s" : [ {
                                 "value" : [ "condition" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "327",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "328",
                           "s" : [ {
                              "value" : [ "\"unconfirmed\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "329",
               "locator" : "216:3-216:46",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "327",
                  "locator" : "216:3-216:30",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "326",
                        "locator" : "216:3-216:11",
                        "name" : "condition",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "328",
                     "locator" : "216:34-216:46",
                     "name" : "unconfirmed",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "325",
                  "locator" : "215:48-215:63",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "340",
            "locator" : "218:1-220:46",
            "name" : "unconfirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "340",
                  "s" : [ {
                     "value" : [ "","define fluent function ","unconfirmed","(","conditions"," " ]
                  }, {
                     "r" : "332",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "331",
                        "s" : [ {
                           "value" : [ "USCore",".","Condition" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "339",
                     "s" : [ {
                        "r" : "339",
                        "s" : [ {
                           "s" : [ {
                              "r" : "334",
                              "s" : [ {
                                 "r" : "333",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "conditions" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","C" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "338",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "338",
                              "s" : [ {
                                 "r" : "336",
                                 "s" : [ {
                                    "r" : "335",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "336",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "337",
                                 "s" : [ {
                                    "value" : [ "\"unconfirmed\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "339",
               "locator" : "219:3-220:46",
               "type" : "Query",
               "source" : [ {
                  "localId" : "334",
                  "locator" : "219:3-219:14",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "333",
                     "locator" : "219:3-219:12",
                     "name" : "conditions",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "338",
                  "locator" : "220:5-220:46",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "336",
                     "locator" : "220:11-220:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "337",
                        "locator" : "220:34-220:46",
                        "name" : "unconfirmed",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "conditions",
               "operandTypeSpecifier" : {
                  "localId" : "332",
                  "locator" : "218:47-218:68",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "331",
                     "locator" : "218:52-218:67",
                     "name" : "{http://hl7.org/fhir}Condition",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "346",
            "locator" : "222:1-223:46",
            "name" : "isProvisional",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "346",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isProvisional","(","condition"," " ]
                  }, {
                     "r" : "341",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "345",
                     "s" : [ {
                        "r" : "345",
                        "s" : [ {
                           "r" : "343",
                           "s" : [ {
                              "r" : "342",
                              "s" : [ {
                                 "value" : [ "condition" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "343",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "344",
                           "s" : [ {
                              "value" : [ "\"provisional\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "345",
               "locator" : "223:3-223:46",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "343",
                  "locator" : "223:3-223:30",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "342",
                        "locator" : "223:3-223:11",
                        "name" : "condition",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "344",
                     "locator" : "223:34-223:46",
                     "name" : "provisional",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "341",
                  "locator" : "222:48-222:63",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "356",
            "locator" : "225:1-227:46",
            "name" : "provisional",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "356",
                  "s" : [ {
                     "value" : [ "","define fluent function ","provisional","(","conditions"," " ]
                  }, {
                     "r" : "348",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "347",
                        "s" : [ {
                           "value" : [ "USCore",".","Condition" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "355",
                     "s" : [ {
                        "r" : "355",
                        "s" : [ {
                           "s" : [ {
                              "r" : "350",
                              "s" : [ {
                                 "r" : "349",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "conditions" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","C" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "354",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "354",
                              "s" : [ {
                                 "r" : "352",
                                 "s" : [ {
                                    "r" : "351",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "352",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "353",
                                 "s" : [ {
                                    "value" : [ "\"provisional\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "355",
               "locator" : "226:3-227:46",
               "type" : "Query",
               "source" : [ {
                  "localId" : "350",
                  "locator" : "226:3-226:14",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "349",
                     "locator" : "226:3-226:12",
                     "name" : "conditions",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "354",
                  "locator" : "227:5-227:46",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "352",
                     "locator" : "227:11-227:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "353",
                        "locator" : "227:34-227:46",
                        "name" : "provisional",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "conditions",
               "operandTypeSpecifier" : {
                  "localId" : "348",
                  "locator" : "225:47-225:68",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "347",
                     "locator" : "225:52-225:67",
                     "name" : "{http://hl7.org/fhir}Condition",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "362",
            "locator" : "229:1-230:47",
            "name" : "isDifferential",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "362",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isDifferential","(","condition"," " ]
                  }, {
                     "r" : "357",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "361",
                     "s" : [ {
                        "r" : "361",
                        "s" : [ {
                           "r" : "359",
                           "s" : [ {
                              "r" : "358",
                              "s" : [ {
                                 "value" : [ "condition" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "359",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "360",
                           "s" : [ {
                              "value" : [ "\"differential\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "361",
               "locator" : "230:3-230:47",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "359",
                  "locator" : "230:3-230:30",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "358",
                        "locator" : "230:3-230:11",
                        "name" : "condition",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "360",
                     "locator" : "230:34-230:47",
                     "name" : "differential",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "357",
                  "locator" : "229:49-229:64",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "372",
            "locator" : "232:1-234:47",
            "name" : "differential",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "372",
                  "s" : [ {
                     "value" : [ "","define fluent function ","differential","(","conditions"," " ]
                  }, {
                     "r" : "364",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "363",
                        "s" : [ {
                           "value" : [ "USCore",".","Condition" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "371",
                     "s" : [ {
                        "r" : "371",
                        "s" : [ {
                           "s" : [ {
                              "r" : "366",
                              "s" : [ {
                                 "r" : "365",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "conditions" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","C" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "370",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "370",
                              "s" : [ {
                                 "r" : "368",
                                 "s" : [ {
                                    "r" : "367",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "368",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "369",
                                 "s" : [ {
                                    "value" : [ "\"differential\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "371",
               "locator" : "233:3-234:47",
               "type" : "Query",
               "source" : [ {
                  "localId" : "366",
                  "locator" : "233:3-233:14",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "365",
                     "locator" : "233:3-233:12",
                     "name" : "conditions",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "370",
                  "locator" : "234:5-234:47",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "368",
                     "locator" : "234:11-234:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "369",
                        "locator" : "234:34-234:47",
                        "name" : "differential",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "conditions",
               "operandTypeSpecifier" : {
                  "localId" : "364",
                  "locator" : "232:48-232:69",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "363",
                     "locator" : "232:53-232:68",
                     "name" : "{http://hl7.org/fhir}Condition",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "378",
            "locator" : "236:1-237:44",
            "name" : "isConfirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "378",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isConfirmed","(","condition"," " ]
                  }, {
                     "r" : "373",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "377",
                     "s" : [ {
                        "r" : "377",
                        "s" : [ {
                           "r" : "375",
                           "s" : [ {
                              "r" : "374",
                              "s" : [ {
                                 "value" : [ "condition" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "375",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "376",
                           "s" : [ {
                              "value" : [ "\"confirmed\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "377",
               "locator" : "237:3-237:44",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "375",
                  "locator" : "237:3-237:30",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "374",
                        "locator" : "237:3-237:11",
                        "name" : "condition",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "376",
                     "locator" : "237:34-237:44",
                     "name" : "confirmed",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "373",
                  "locator" : "236:46-236:61",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "388",
            "locator" : "239:1-241:44",
            "name" : "confirmed",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "388",
                  "s" : [ {
                     "value" : [ "","define fluent function ","confirmed","(","conditions"," " ]
                  }, {
                     "r" : "380",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "379",
                        "s" : [ {
                           "value" : [ "USCore",".","Condition" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "387",
                     "s" : [ {
                        "r" : "387",
                        "s" : [ {
                           "s" : [ {
                              "r" : "382",
                              "s" : [ {
                                 "r" : "381",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "conditions" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","C" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "386",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "386",
                              "s" : [ {
                                 "r" : "384",
                                 "s" : [ {
                                    "r" : "383",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "384",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "385",
                                 "s" : [ {
                                    "value" : [ "\"confirmed\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "387",
               "locator" : "240:3-241:44",
               "type" : "Query",
               "source" : [ {
                  "localId" : "382",
                  "locator" : "240:3-240:14",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "381",
                     "locator" : "240:3-240:12",
                     "name" : "conditions",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "386",
                  "locator" : "241:5-241:44",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "384",
                     "locator" : "241:11-241:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "385",
                        "locator" : "241:34-241:44",
                        "name" : "confirmed",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "conditions",
               "operandTypeSpecifier" : {
                  "localId" : "380",
                  "locator" : "239:45-239:66",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "379",
                     "locator" : "239:50-239:65",
                     "name" : "{http://hl7.org/fhir}Condition",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "394",
            "locator" : "243:1-244:42",
            "name" : "isRefuted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "394",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isRefuted","(","condition"," " ]
                  }, {
                     "r" : "389",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "393",
                     "s" : [ {
                        "r" : "393",
                        "s" : [ {
                           "r" : "391",
                           "s" : [ {
                              "r" : "390",
                              "s" : [ {
                                 "value" : [ "condition" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "391",
                              "s" : [ {
                                 "value" : [ "verificationStatus" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "392",
                           "s" : [ {
                              "value" : [ "\"refuted\"" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "393",
               "locator" : "244:3-244:42",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "391",
                  "locator" : "244:3-244:30",
                  "name" : "ToConcept",
                  "libraryName" : "FHIRHelpers",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "path" : "verificationStatus",
                     "type" : "Property",
                     "source" : {
                        "localId" : "390",
                        "locator" : "244:3-244:11",
                        "name" : "condition",
                        "type" : "OperandRef"
                     }
                  } ]
               }, {
                  "type" : "ToConcept",
                  "operand" : {
                     "localId" : "392",
                     "locator" : "244:34-244:42",
                     "name" : "refuted",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "389",
                  "locator" : "243:44-243:59",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "404",
            "locator" : "246:1-248:42",
            "name" : "refuted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "404",
                  "s" : [ {
                     "value" : [ "","define fluent function ","refuted","(","conditions"," " ]
                  }, {
                     "r" : "396",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "395",
                        "s" : [ {
                           "value" : [ "USCore",".","Condition" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "403",
                     "s" : [ {
                        "r" : "403",
                        "s" : [ {
                           "s" : [ {
                              "r" : "398",
                              "s" : [ {
                                 "r" : "397",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "conditions" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","C" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "402",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "402",
                              "s" : [ {
                                 "r" : "400",
                                 "s" : [ {
                                    "r" : "399",
                                    "s" : [ {
                                       "value" : [ "C" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "400",
                                    "s" : [ {
                                       "value" : [ "verificationStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "401",
                                 "s" : [ {
                                    "value" : [ "\"refuted\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "403",
               "locator" : "247:3-248:42",
               "type" : "Query",
               "source" : [ {
                  "localId" : "398",
                  "locator" : "247:3-247:14",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "397",
                     "locator" : "247:3-247:12",
                     "name" : "conditions",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "402",
                  "locator" : "248:5-248:42",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "400",
                     "locator" : "248:11-248:30",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "verificationStatus",
                        "scope" : "C",
                        "type" : "Property"
                     } ]
                  }, {
                     "type" : "ToConcept",
                     "operand" : {
                        "localId" : "401",
                        "locator" : "248:34-248:42",
                        "name" : "refuted",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "conditions",
               "operandTypeSpecifier" : {
                  "localId" : "396",
                  "locator" : "246:43-246:64",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "395",
                     "locator" : "246:48-246:63",
                     "name" : "{http://hl7.org/fhir}Condition",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "414",
            "locator" : "253:1-256:3",
            "name" : "hasCategory",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given observation has the given category"
               } ],
               "s" : {
                  "r" : "414",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given observation has the given category\n*/\n","define fluent function ","hasCategory","(","observation"," " ]
                  }, {
                     "r" : "405",
                     "s" : [ {
                        "value" : [ "LaboratoryResultObservationProfile" ]
                     } ]
                  }, {
                     "value" : [ ", ","category"," " ]
                  }, {
                     "r" : "406",
                     "s" : [ {
                        "value" : [ "Code" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "413",
                     "s" : [ {
                        "r" : "413",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "412",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "412",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "408",
                                    "s" : [ {
                                       "r" : "407",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "observation",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "411",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "411",
                                    "s" : [ {
                                       "r" : "409",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "410",
                                       "s" : [ {
                                          "value" : [ "category" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "413",
               "locator" : "254:3-256:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "412",
                  "locator" : "254:10-256:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "408",
                     "locator" : "254:11-254:32",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "407",
                        "locator" : "254:11-254:30",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "observation",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "411",
                     "locator" : "255:5-255:22",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "409",
                        "locator" : "255:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "410",
                           "locator" : "255:15-255:22",
                           "name" : "category",
                           "type" : "OperandRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "405",
                  "locator" : "253:48-253:81",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "category",
               "operandTypeSpecifier" : {
                  "localId" : "406",
                  "locator" : "253:93-253:96",
                  "name" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "433",
            "locator" : "261:1-264:56",
            "name" : "isResulted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given observation has status"
               } ],
               "s" : {
                  "r" : "433",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given observation has status\n*/\n","define fluent function ","isResulted","(","observation"," " ]
                  }, {
                     "r" : "415",
                     "s" : [ {
                        "value" : [ "LaboratoryResultObservationProfile" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "432",
                     "s" : [ {
                        "r" : "432",
                        "s" : [ {
                           "r" : "426",
                           "s" : [ {
                              "r" : "420",
                              "s" : [ {
                                 "r" : "417",
                                 "s" : [ {
                                    "r" : "416",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "417",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "419",
                                 "s" : [ {
                                    "r" : "418",
                                    "s" : [ {
                                       "value" : [ "\"observation-final\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "419",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    or " ]
                           }, {
                              "r" : "425",
                              "s" : [ {
                                 "r" : "422",
                                 "s" : [ {
                                    "r" : "421",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "422",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "424",
                                 "s" : [ {
                                    "r" : "423",
                                    "s" : [ {
                                       "value" : [ "\"observation-amended\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "424",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "431",
                           "s" : [ {
                              "r" : "428",
                              "s" : [ {
                                 "r" : "427",
                                 "s" : [ {
                                    "value" : [ "observation" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "428",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","~"," " ]
                           }, {
                              "r" : "430",
                              "s" : [ {
                                 "r" : "429",
                                 "s" : [ {
                                    "value" : [ "\"observation-corrected\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "430",
                                 "s" : [ {
                                    "value" : [ "code" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "432",
               "locator" : "262:3-264:56",
               "type" : "Or",
               "operand" : [ {
                  "localId" : "426",
                  "locator" : "262:3-263:54",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "420",
                     "locator" : "262:3-262:47",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "417",
                        "locator" : "262:3-262:20",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "type" : "Property",
                           "source" : {
                              "localId" : "416",
                              "locator" : "262:3-262:13",
                              "name" : "observation",
                              "type" : "OperandRef"
                           }
                        }
                     }, {
                        "localId" : "419",
                        "locator" : "262:24-262:47",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "418",
                           "locator" : "262:24-262:42",
                           "name" : "observation-final",
                           "type" : "CodeRef"
                        }
                     } ]
                  }, {
                     "localId" : "425",
                     "locator" : "263:8-263:54",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "422",
                        "locator" : "263:8-263:25",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "type" : "Property",
                           "source" : {
                              "localId" : "421",
                              "locator" : "263:8-263:18",
                              "name" : "observation",
                              "type" : "OperandRef"
                           }
                        }
                     }, {
                        "localId" : "424",
                        "locator" : "263:29-263:54",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "423",
                           "locator" : "263:29-263:49",
                           "name" : "observation-amended",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }, {
                  "localId" : "431",
                  "locator" : "264:8-264:56",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "428",
                     "locator" : "264:8-264:25",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "type" : "Property",
                        "source" : {
                           "localId" : "427",
                           "locator" : "264:8-264:18",
                           "name" : "observation",
                           "type" : "OperandRef"
                        }
                     }
                  }, {
                     "localId" : "430",
                     "locator" : "264:29-264:56",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "429",
                        "locator" : "264:29-264:51",
                        "name" : "observation-corrected",
                        "type" : "CodeRef"
                     }
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "415",
                  "locator" : "261:47-261:80",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "456",
            "locator" : "266:1-270:58",
            "name" : "resulted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "456",
                  "s" : [ {
                     "value" : [ "","define fluent function ","resulted","(","observations"," " ]
                  }, {
                     "r" : "435",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "434",
                        "s" : [ {
                           "value" : [ "LaboratoryResultObservationProfile" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "455",
                     "s" : [ {
                        "r" : "455",
                        "s" : [ {
                           "s" : [ {
                              "r" : "437",
                              "s" : [ {
                                 "r" : "436",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "454",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "454",
                              "s" : [ {
                                 "r" : "448",
                                 "s" : [ {
                                    "r" : "442",
                                    "s" : [ {
                                       "r" : "439",
                                       "s" : [ {
                                          "r" : "438",
                                          "s" : [ {
                                             "value" : [ "observation" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "439",
                                          "s" : [ {
                                             "value" : [ "status" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "441",
                                       "s" : [ {
                                          "r" : "440",
                                          "s" : [ {
                                             "value" : [ "\"observation-final\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "441",
                                          "s" : [ {
                                             "value" : [ "code" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n      or " ]
                                 }, {
                                    "r" : "447",
                                    "s" : [ {
                                       "r" : "444",
                                       "s" : [ {
                                          "r" : "443",
                                          "s" : [ {
                                             "value" : [ "observation" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "444",
                                          "s" : [ {
                                             "value" : [ "status" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "446",
                                       "s" : [ {
                                          "r" : "445",
                                          "s" : [ {
                                             "value" : [ "\"observation-amended\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "446",
                                          "s" : [ {
                                             "value" : [ "code" ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      or " ]
                              }, {
                                 "r" : "453",
                                 "s" : [ {
                                    "r" : "450",
                                    "s" : [ {
                                       "r" : "449",
                                       "s" : [ {
                                          "value" : [ "observation" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "450",
                                       "s" : [ {
                                          "value" : [ "status" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "452",
                                    "s" : [ {
                                       "r" : "451",
                                       "s" : [ {
                                          "value" : [ "\"observation-corrected\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "452",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "455",
               "locator" : "267:3-270:58",
               "type" : "Query",
               "source" : [ {
                  "localId" : "437",
                  "locator" : "267:3-267:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "436",
                     "locator" : "267:3-267:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "454",
                  "locator" : "268:5-270:58",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "448",
                     "locator" : "268:11-269:56",
                     "type" : "Or",
                     "operand" : [ {
                        "localId" : "442",
                        "locator" : "268:11-268:55",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "439",
                           "locator" : "268:11-268:28",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "status",
                              "scope" : "observation",
                              "type" : "Property"
                           }
                        }, {
                           "localId" : "441",
                           "locator" : "268:32-268:55",
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "localId" : "440",
                              "locator" : "268:32-268:50",
                              "name" : "observation-final",
                              "type" : "CodeRef"
                           }
                        } ]
                     }, {
                        "localId" : "447",
                        "locator" : "269:10-269:56",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "444",
                           "locator" : "269:10-269:27",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "status",
                              "scope" : "observation",
                              "type" : "Property"
                           }
                        }, {
                           "localId" : "446",
                           "locator" : "269:31-269:56",
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "localId" : "445",
                              "locator" : "269:31-269:51",
                              "name" : "observation-amended",
                              "type" : "CodeRef"
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "453",
                     "locator" : "270:10-270:58",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "450",
                        "locator" : "270:10-270:27",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "scope" : "observation",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "452",
                        "locator" : "270:31-270:58",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "451",
                           "locator" : "270:31-270:53",
                           "name" : "observation-corrected",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "435",
                  "locator" : "266:46-266:85",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "434",
                     "locator" : "266:51-266:84",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "463",
            "locator" : "272:1-273:47",
            "name" : "isFinal",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "463",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isFinal","(","observation"," " ]
                  }, {
                     "r" : "457",
                     "s" : [ {
                        "value" : [ "LaboratoryResultObservationProfile" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "462",
                     "s" : [ {
                        "r" : "462",
                        "s" : [ {
                           "r" : "459",
                           "s" : [ {
                              "r" : "458",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "459",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "461",
                           "s" : [ {
                              "r" : "460",
                              "s" : [ {
                                 "value" : [ "\"observation-final\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "461",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "462",
               "locator" : "273:3-273:47",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "459",
                  "locator" : "273:3-273:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "458",
                        "locator" : "273:3-273:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "461",
                  "locator" : "273:24-273:47",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "460",
                     "locator" : "273:24-273:42",
                     "name" : "observation-final",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "457",
                  "locator" : "272:44-272:77",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "474",
            "locator" : "275:1-277:55",
            "name" : "final",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "474",
                  "s" : [ {
                     "value" : [ "","define fluent function ","final","(","observations"," " ]
                  }, {
                     "r" : "465",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "464",
                        "s" : [ {
                           "value" : [ "LaboratoryResultObservationProfile" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "473",
                     "s" : [ {
                        "r" : "473",
                        "s" : [ {
                           "s" : [ {
                              "r" : "467",
                              "s" : [ {
                                 "r" : "466",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "472",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "472",
                              "s" : [ {
                                 "r" : "469",
                                 "s" : [ {
                                    "r" : "468",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "469",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "471",
                                 "s" : [ {
                                    "r" : "470",
                                    "s" : [ {
                                       "value" : [ "\"observation-final\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "471",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "473",
               "locator" : "276:3-277:55",
               "type" : "Query",
               "source" : [ {
                  "localId" : "467",
                  "locator" : "276:3-276:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "466",
                     "locator" : "276:3-276:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "472",
                  "locator" : "277:5-277:55",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "469",
                     "locator" : "277:11-277:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "471",
                     "locator" : "277:32-277:55",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "470",
                        "locator" : "277:32-277:50",
                        "name" : "observation-final",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "465",
                  "locator" : "275:43-275:82",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "464",
                     "locator" : "275:48-275:81",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "481",
            "locator" : "279:1-280:49",
            "name" : "isAmended",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "481",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAmended","(","observation"," " ]
                  }, {
                     "r" : "475",
                     "s" : [ {
                        "value" : [ "LaboratoryResultObservationProfile" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "480",
                     "s" : [ {
                        "r" : "480",
                        "s" : [ {
                           "r" : "477",
                           "s" : [ {
                              "r" : "476",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "477",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "479",
                           "s" : [ {
                              "r" : "478",
                              "s" : [ {
                                 "value" : [ "\"observation-amended\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "479",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "480",
               "locator" : "280:3-280:49",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "477",
                  "locator" : "280:3-280:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "476",
                        "locator" : "280:3-280:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "479",
                  "locator" : "280:24-280:49",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "478",
                     "locator" : "280:24-280:44",
                     "name" : "observation-amended",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "475",
                  "locator" : "279:46-279:79",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "492",
            "locator" : "282:1-284:57",
            "name" : "amended",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "492",
                  "s" : [ {
                     "value" : [ "","define fluent function ","amended","(","observations"," " ]
                  }, {
                     "r" : "483",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "482",
                        "s" : [ {
                           "value" : [ "LaboratoryResultObservationProfile" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "491",
                     "s" : [ {
                        "r" : "491",
                        "s" : [ {
                           "s" : [ {
                              "r" : "485",
                              "s" : [ {
                                 "r" : "484",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "490",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "490",
                              "s" : [ {
                                 "r" : "487",
                                 "s" : [ {
                                    "r" : "486",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "487",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "489",
                                 "s" : [ {
                                    "r" : "488",
                                    "s" : [ {
                                       "value" : [ "\"observation-amended\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "489",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "491",
               "locator" : "283:3-284:57",
               "type" : "Query",
               "source" : [ {
                  "localId" : "485",
                  "locator" : "283:3-283:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "484",
                     "locator" : "283:3-283:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "490",
                  "locator" : "284:5-284:57",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "487",
                     "locator" : "284:11-284:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "489",
                     "locator" : "284:32-284:57",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "488",
                        "locator" : "284:32-284:52",
                        "name" : "observation-amended",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "483",
                  "locator" : "282:45-282:84",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "482",
                     "locator" : "282:50-282:83",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "499",
            "locator" : "286:1-287:51",
            "name" : "isCorrected",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "499",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isCorrected","(","observation"," " ]
                  }, {
                     "r" : "493",
                     "s" : [ {
                        "value" : [ "LaboratoryResultObservationProfile" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "498",
                     "s" : [ {
                        "r" : "498",
                        "s" : [ {
                           "r" : "495",
                           "s" : [ {
                              "r" : "494",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "495",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "497",
                           "s" : [ {
                              "r" : "496",
                              "s" : [ {
                                 "value" : [ "\"observation-corrected\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "497",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "498",
               "locator" : "287:3-287:51",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "495",
                  "locator" : "287:3-287:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "494",
                        "locator" : "287:3-287:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "497",
                  "locator" : "287:24-287:51",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "496",
                     "locator" : "287:24-287:46",
                     "name" : "observation-corrected",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "493",
                  "locator" : "286:48-286:81",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "510",
            "locator" : "289:1-291:59",
            "name" : "corrected",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "510",
                  "s" : [ {
                     "value" : [ "","define fluent function ","corrected","(","observations"," " ]
                  }, {
                     "r" : "501",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "500",
                        "s" : [ {
                           "value" : [ "LaboratoryResultObservationProfile" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "509",
                     "s" : [ {
                        "r" : "509",
                        "s" : [ {
                           "s" : [ {
                              "r" : "503",
                              "s" : [ {
                                 "r" : "502",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "508",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "508",
                              "s" : [ {
                                 "r" : "505",
                                 "s" : [ {
                                    "r" : "504",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "505",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "507",
                                 "s" : [ {
                                    "r" : "506",
                                    "s" : [ {
                                       "value" : [ "\"observation-corrected\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "507",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "509",
               "locator" : "290:3-291:59",
               "type" : "Query",
               "source" : [ {
                  "localId" : "503",
                  "locator" : "290:3-290:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "502",
                     "locator" : "290:3-290:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "508",
                  "locator" : "291:5-291:59",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "505",
                     "locator" : "291:11-291:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "507",
                     "locator" : "291:32-291:59",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "506",
                        "locator" : "291:32-291:54",
                        "name" : "observation-corrected",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "501",
                  "locator" : "289:47-289:86",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "500",
                     "locator" : "289:52-289:85",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "529",
            "locator" : "294:1-297:56",
            "name" : "isResulted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "529",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isResulted","(","observation"," " ]
                  }, {
                     "r" : "511",
                     "s" : [ {
                        "value" : [ "\"observation-bodyweight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "528",
                     "s" : [ {
                        "r" : "528",
                        "s" : [ {
                           "r" : "522",
                           "s" : [ {
                              "r" : "516",
                              "s" : [ {
                                 "r" : "513",
                                 "s" : [ {
                                    "r" : "512",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "513",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "515",
                                 "s" : [ {
                                    "r" : "514",
                                    "s" : [ {
                                       "value" : [ "\"observation-final\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "515",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    or " ]
                           }, {
                              "r" : "521",
                              "s" : [ {
                                 "r" : "518",
                                 "s" : [ {
                                    "r" : "517",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "518",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "520",
                                 "s" : [ {
                                    "r" : "519",
                                    "s" : [ {
                                       "value" : [ "\"observation-amended\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "520",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "527",
                           "s" : [ {
                              "r" : "524",
                              "s" : [ {
                                 "r" : "523",
                                 "s" : [ {
                                    "value" : [ "observation" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "524",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","~"," " ]
                           }, {
                              "r" : "526",
                              "s" : [ {
                                 "r" : "525",
                                 "s" : [ {
                                    "value" : [ "\"observation-corrected\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "526",
                                 "s" : [ {
                                    "value" : [ "code" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "528",
               "locator" : "295:3-297:56",
               "type" : "Or",
               "operand" : [ {
                  "localId" : "522",
                  "locator" : "295:3-296:54",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "516",
                     "locator" : "295:3-295:47",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "513",
                        "locator" : "295:3-295:20",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "type" : "Property",
                           "source" : {
                              "localId" : "512",
                              "locator" : "295:3-295:13",
                              "name" : "observation",
                              "type" : "OperandRef"
                           }
                        }
                     }, {
                        "localId" : "515",
                        "locator" : "295:24-295:47",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "514",
                           "locator" : "295:24-295:42",
                           "name" : "observation-final",
                           "type" : "CodeRef"
                        }
                     } ]
                  }, {
                     "localId" : "521",
                     "locator" : "296:8-296:54",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "518",
                        "locator" : "296:8-296:25",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "type" : "Property",
                           "source" : {
                              "localId" : "517",
                              "locator" : "296:8-296:18",
                              "name" : "observation",
                              "type" : "OperandRef"
                           }
                        }
                     }, {
                        "localId" : "520",
                        "locator" : "296:29-296:54",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "519",
                           "locator" : "296:29-296:49",
                           "name" : "observation-amended",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }, {
                  "localId" : "527",
                  "locator" : "297:8-297:56",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "524",
                     "locator" : "297:8-297:25",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "type" : "Property",
                        "source" : {
                           "localId" : "523",
                           "locator" : "297:8-297:18",
                           "name" : "observation",
                           "type" : "OperandRef"
                        }
                     }
                  }, {
                     "localId" : "526",
                     "locator" : "297:29-297:56",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "525",
                        "locator" : "297:29-297:51",
                        "name" : "observation-corrected",
                        "type" : "CodeRef"
                     }
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "511",
                  "locator" : "294:47-294:70",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "552",
            "locator" : "299:1-303:58",
            "name" : "resulted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "552",
                  "s" : [ {
                     "value" : [ "","define fluent function ","resulted","(","observations"," " ]
                  }, {
                     "r" : "531",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "530",
                        "s" : [ {
                           "value" : [ "\"observation-bodyweight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "551",
                     "s" : [ {
                        "r" : "551",
                        "s" : [ {
                           "s" : [ {
                              "r" : "533",
                              "s" : [ {
                                 "r" : "532",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "550",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "550",
                              "s" : [ {
                                 "r" : "544",
                                 "s" : [ {
                                    "r" : "538",
                                    "s" : [ {
                                       "r" : "535",
                                       "s" : [ {
                                          "r" : "534",
                                          "s" : [ {
                                             "value" : [ "observation" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "535",
                                          "s" : [ {
                                             "value" : [ "status" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "537",
                                       "s" : [ {
                                          "r" : "536",
                                          "s" : [ {
                                             "value" : [ "\"observation-final\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "537",
                                          "s" : [ {
                                             "value" : [ "code" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n      or " ]
                                 }, {
                                    "r" : "543",
                                    "s" : [ {
                                       "r" : "540",
                                       "s" : [ {
                                          "r" : "539",
                                          "s" : [ {
                                             "value" : [ "observation" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "540",
                                          "s" : [ {
                                             "value" : [ "status" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "542",
                                       "s" : [ {
                                          "r" : "541",
                                          "s" : [ {
                                             "value" : [ "\"observation-amended\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "542",
                                          "s" : [ {
                                             "value" : [ "code" ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      or " ]
                              }, {
                                 "r" : "549",
                                 "s" : [ {
                                    "r" : "546",
                                    "s" : [ {
                                       "r" : "545",
                                       "s" : [ {
                                          "value" : [ "observation" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "546",
                                       "s" : [ {
                                          "value" : [ "status" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "548",
                                    "s" : [ {
                                       "r" : "547",
                                       "s" : [ {
                                          "value" : [ "\"observation-corrected\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "548",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "551",
               "locator" : "300:3-303:58",
               "type" : "Query",
               "source" : [ {
                  "localId" : "533",
                  "locator" : "300:3-300:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "532",
                     "locator" : "300:3-300:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "550",
                  "locator" : "301:5-303:58",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "544",
                     "locator" : "301:11-302:56",
                     "type" : "Or",
                     "operand" : [ {
                        "localId" : "538",
                        "locator" : "301:11-301:55",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "535",
                           "locator" : "301:11-301:28",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "status",
                              "scope" : "observation",
                              "type" : "Property"
                           }
                        }, {
                           "localId" : "537",
                           "locator" : "301:32-301:55",
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "localId" : "536",
                              "locator" : "301:32-301:50",
                              "name" : "observation-final",
                              "type" : "CodeRef"
                           }
                        } ]
                     }, {
                        "localId" : "543",
                        "locator" : "302:10-302:56",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "540",
                           "locator" : "302:10-302:27",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "status",
                              "scope" : "observation",
                              "type" : "Property"
                           }
                        }, {
                           "localId" : "542",
                           "locator" : "302:31-302:56",
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "localId" : "541",
                              "locator" : "302:31-302:51",
                              "name" : "observation-amended",
                              "type" : "CodeRef"
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "549",
                     "locator" : "303:10-303:58",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "546",
                        "locator" : "303:10-303:27",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "scope" : "observation",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "548",
                        "locator" : "303:31-303:58",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "547",
                           "locator" : "303:31-303:53",
                           "name" : "observation-corrected",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "531",
                  "locator" : "299:46-299:75",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "530",
                     "locator" : "299:51-299:74",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "559",
            "locator" : "305:1-306:47",
            "name" : "isFinal",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "559",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isFinal","(","observation"," " ]
                  }, {
                     "r" : "553",
                     "s" : [ {
                        "value" : [ "\"observation-bodyweight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "558",
                     "s" : [ {
                        "r" : "558",
                        "s" : [ {
                           "r" : "555",
                           "s" : [ {
                              "r" : "554",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "555",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "557",
                           "s" : [ {
                              "r" : "556",
                              "s" : [ {
                                 "value" : [ "\"observation-final\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "557",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "558",
               "locator" : "306:3-306:47",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "555",
                  "locator" : "306:3-306:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "554",
                        "locator" : "306:3-306:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "557",
                  "locator" : "306:24-306:47",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "556",
                     "locator" : "306:24-306:42",
                     "name" : "observation-final",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "553",
                  "locator" : "305:44-305:67",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "570",
            "locator" : "308:1-310:55",
            "name" : "final",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "570",
                  "s" : [ {
                     "value" : [ "","define fluent function ","final","(","observations"," " ]
                  }, {
                     "r" : "561",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "560",
                        "s" : [ {
                           "value" : [ "\"observation-bodyweight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "569",
                     "s" : [ {
                        "r" : "569",
                        "s" : [ {
                           "s" : [ {
                              "r" : "563",
                              "s" : [ {
                                 "r" : "562",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "568",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "568",
                              "s" : [ {
                                 "r" : "565",
                                 "s" : [ {
                                    "r" : "564",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "565",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "567",
                                 "s" : [ {
                                    "r" : "566",
                                    "s" : [ {
                                       "value" : [ "\"observation-final\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "567",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "569",
               "locator" : "309:3-310:55",
               "type" : "Query",
               "source" : [ {
                  "localId" : "563",
                  "locator" : "309:3-309:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "562",
                     "locator" : "309:3-309:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "568",
                  "locator" : "310:5-310:55",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "565",
                     "locator" : "310:11-310:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "567",
                     "locator" : "310:32-310:55",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "566",
                        "locator" : "310:32-310:50",
                        "name" : "observation-final",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "561",
                  "locator" : "308:43-308:72",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "560",
                     "locator" : "308:48-308:71",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "577",
            "locator" : "312:1-313:49",
            "name" : "isAmended",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "577",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAmended","(","observation"," " ]
                  }, {
                     "r" : "571",
                     "s" : [ {
                        "value" : [ "\"observation-bodyweight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "576",
                     "s" : [ {
                        "r" : "576",
                        "s" : [ {
                           "r" : "573",
                           "s" : [ {
                              "r" : "572",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "573",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "575",
                           "s" : [ {
                              "r" : "574",
                              "s" : [ {
                                 "value" : [ "\"observation-amended\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "575",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "576",
               "locator" : "313:3-313:49",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "573",
                  "locator" : "313:3-313:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "572",
                        "locator" : "313:3-313:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "575",
                  "locator" : "313:24-313:49",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "574",
                     "locator" : "313:24-313:44",
                     "name" : "observation-amended",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "571",
                  "locator" : "312:46-312:69",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "588",
            "locator" : "315:1-317:57",
            "name" : "amended",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "588",
                  "s" : [ {
                     "value" : [ "","define fluent function ","amended","(","observations"," " ]
                  }, {
                     "r" : "579",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "578",
                        "s" : [ {
                           "value" : [ "\"observation-bodyweight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "587",
                     "s" : [ {
                        "r" : "587",
                        "s" : [ {
                           "s" : [ {
                              "r" : "581",
                              "s" : [ {
                                 "r" : "580",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "586",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "586",
                              "s" : [ {
                                 "r" : "583",
                                 "s" : [ {
                                    "r" : "582",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "583",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "585",
                                 "s" : [ {
                                    "r" : "584",
                                    "s" : [ {
                                       "value" : [ "\"observation-amended\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "585",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "587",
               "locator" : "316:3-317:57",
               "type" : "Query",
               "source" : [ {
                  "localId" : "581",
                  "locator" : "316:3-316:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "580",
                     "locator" : "316:3-316:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "586",
                  "locator" : "317:5-317:57",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "583",
                     "locator" : "317:11-317:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "585",
                     "locator" : "317:32-317:57",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "584",
                        "locator" : "317:32-317:52",
                        "name" : "observation-amended",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "579",
                  "locator" : "315:45-315:74",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "578",
                     "locator" : "315:50-315:73",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "595",
            "locator" : "319:1-320:51",
            "name" : "isCorrected",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "595",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isCorrected","(","observation"," " ]
                  }, {
                     "r" : "589",
                     "s" : [ {
                        "value" : [ "\"observation-bodyweight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "594",
                     "s" : [ {
                        "r" : "594",
                        "s" : [ {
                           "r" : "591",
                           "s" : [ {
                              "r" : "590",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "591",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "593",
                           "s" : [ {
                              "r" : "592",
                              "s" : [ {
                                 "value" : [ "\"observation-corrected\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "593",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "594",
               "locator" : "320:3-320:51",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "591",
                  "locator" : "320:3-320:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "590",
                        "locator" : "320:3-320:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "593",
                  "locator" : "320:24-320:51",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "592",
                     "locator" : "320:24-320:46",
                     "name" : "observation-corrected",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "589",
                  "locator" : "319:48-319:71",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "606",
            "locator" : "322:1-324:59",
            "name" : "corrected",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "606",
                  "s" : [ {
                     "value" : [ "","define fluent function ","corrected","(","observations"," " ]
                  }, {
                     "r" : "597",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "596",
                        "s" : [ {
                           "value" : [ "\"observation-bodyweight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "605",
                     "s" : [ {
                        "r" : "605",
                        "s" : [ {
                           "s" : [ {
                              "r" : "599",
                              "s" : [ {
                                 "r" : "598",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "604",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "604",
                              "s" : [ {
                                 "r" : "601",
                                 "s" : [ {
                                    "r" : "600",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "601",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "603",
                                 "s" : [ {
                                    "r" : "602",
                                    "s" : [ {
                                       "value" : [ "\"observation-corrected\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "603",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "605",
               "locator" : "323:3-324:59",
               "type" : "Query",
               "source" : [ {
                  "localId" : "599",
                  "locator" : "323:3-323:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "598",
                     "locator" : "323:3-323:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "604",
                  "locator" : "324:5-324:59",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "601",
                     "locator" : "324:11-324:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "603",
                     "locator" : "324:32-324:59",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "602",
                        "locator" : "324:32-324:54",
                        "name" : "observation-corrected",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "597",
                  "locator" : "322:47-322:76",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "596",
                     "locator" : "322:52-322:75",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "625",
            "locator" : "327:1-330:56",
            "name" : "isResulted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "625",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isResulted","(","observation"," " ]
                  }, {
                     "r" : "607",
                     "s" : [ {
                        "value" : [ "\"observation-bodyheight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "624",
                     "s" : [ {
                        "r" : "624",
                        "s" : [ {
                           "r" : "618",
                           "s" : [ {
                              "r" : "612",
                              "s" : [ {
                                 "r" : "609",
                                 "s" : [ {
                                    "r" : "608",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "609",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "611",
                                 "s" : [ {
                                    "r" : "610",
                                    "s" : [ {
                                       "value" : [ "\"observation-final\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "611",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n    or " ]
                           }, {
                              "r" : "617",
                              "s" : [ {
                                 "r" : "614",
                                 "s" : [ {
                                    "r" : "613",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "614",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "616",
                                 "s" : [ {
                                    "r" : "615",
                                    "s" : [ {
                                       "value" : [ "\"observation-amended\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "616",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    or " ]
                        }, {
                           "r" : "623",
                           "s" : [ {
                              "r" : "620",
                              "s" : [ {
                                 "r" : "619",
                                 "s" : [ {
                                    "value" : [ "observation" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "620",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","~"," " ]
                           }, {
                              "r" : "622",
                              "s" : [ {
                                 "r" : "621",
                                 "s" : [ {
                                    "value" : [ "\"observation-corrected\"" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "622",
                                 "s" : [ {
                                    "value" : [ "code" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "624",
               "locator" : "328:3-330:56",
               "type" : "Or",
               "operand" : [ {
                  "localId" : "618",
                  "locator" : "328:3-329:54",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "612",
                     "locator" : "328:3-328:47",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "609",
                        "locator" : "328:3-328:20",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "type" : "Property",
                           "source" : {
                              "localId" : "608",
                              "locator" : "328:3-328:13",
                              "name" : "observation",
                              "type" : "OperandRef"
                           }
                        }
                     }, {
                        "localId" : "611",
                        "locator" : "328:24-328:47",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "610",
                           "locator" : "328:24-328:42",
                           "name" : "observation-final",
                           "type" : "CodeRef"
                        }
                     } ]
                  }, {
                     "localId" : "617",
                     "locator" : "329:8-329:54",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "614",
                        "locator" : "329:8-329:25",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "type" : "Property",
                           "source" : {
                              "localId" : "613",
                              "locator" : "329:8-329:18",
                              "name" : "observation",
                              "type" : "OperandRef"
                           }
                        }
                     }, {
                        "localId" : "616",
                        "locator" : "329:29-329:54",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "615",
                           "locator" : "329:29-329:49",
                           "name" : "observation-amended",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }, {
                  "localId" : "623",
                  "locator" : "330:8-330:56",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "620",
                     "locator" : "330:8-330:25",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "type" : "Property",
                        "source" : {
                           "localId" : "619",
                           "locator" : "330:8-330:18",
                           "name" : "observation",
                           "type" : "OperandRef"
                        }
                     }
                  }, {
                     "localId" : "622",
                     "locator" : "330:29-330:56",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "621",
                        "locator" : "330:29-330:51",
                        "name" : "observation-corrected",
                        "type" : "CodeRef"
                     }
                  } ]
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "607",
                  "locator" : "327:47-327:70",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "648",
            "locator" : "332:1-336:58",
            "name" : "resulted",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "648",
                  "s" : [ {
                     "value" : [ "","define fluent function ","resulted","(","observations"," " ]
                  }, {
                     "r" : "627",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "626",
                        "s" : [ {
                           "value" : [ "\"observation-bodyheight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "647",
                     "s" : [ {
                        "r" : "647",
                        "s" : [ {
                           "s" : [ {
                              "r" : "629",
                              "s" : [ {
                                 "r" : "628",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "646",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "646",
                              "s" : [ {
                                 "r" : "640",
                                 "s" : [ {
                                    "r" : "634",
                                    "s" : [ {
                                       "r" : "631",
                                       "s" : [ {
                                          "r" : "630",
                                          "s" : [ {
                                             "value" : [ "observation" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "631",
                                          "s" : [ {
                                             "value" : [ "status" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "633",
                                       "s" : [ {
                                          "r" : "632",
                                          "s" : [ {
                                             "value" : [ "\"observation-final\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "633",
                                          "s" : [ {
                                             "value" : [ "code" ]
                                          } ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n      or " ]
                                 }, {
                                    "r" : "639",
                                    "s" : [ {
                                       "r" : "636",
                                       "s" : [ {
                                          "r" : "635",
                                          "s" : [ {
                                             "value" : [ "observation" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "636",
                                          "s" : [ {
                                             "value" : [ "status" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "638",
                                       "s" : [ {
                                          "r" : "637",
                                          "s" : [ {
                                             "value" : [ "\"observation-amended\"" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "638",
                                          "s" : [ {
                                             "value" : [ "code" ]
                                          } ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      or " ]
                              }, {
                                 "r" : "645",
                                 "s" : [ {
                                    "r" : "642",
                                    "s" : [ {
                                       "r" : "641",
                                       "s" : [ {
                                          "value" : [ "observation" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "642",
                                       "s" : [ {
                                          "value" : [ "status" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "644",
                                    "s" : [ {
                                       "r" : "643",
                                       "s" : [ {
                                          "value" : [ "\"observation-corrected\"" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "644",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "647",
               "locator" : "333:3-336:58",
               "type" : "Query",
               "source" : [ {
                  "localId" : "629",
                  "locator" : "333:3-333:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "628",
                     "locator" : "333:3-333:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "646",
                  "locator" : "334:5-336:58",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "640",
                     "locator" : "334:11-335:56",
                     "type" : "Or",
                     "operand" : [ {
                        "localId" : "634",
                        "locator" : "334:11-334:55",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "631",
                           "locator" : "334:11-334:28",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "status",
                              "scope" : "observation",
                              "type" : "Property"
                           }
                        }, {
                           "localId" : "633",
                           "locator" : "334:32-334:55",
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "localId" : "632",
                              "locator" : "334:32-334:50",
                              "name" : "observation-final",
                              "type" : "CodeRef"
                           }
                        } ]
                     }, {
                        "localId" : "639",
                        "locator" : "335:10-335:56",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "636",
                           "locator" : "335:10-335:27",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "path" : "status",
                              "scope" : "observation",
                              "type" : "Property"
                           }
                        }, {
                           "localId" : "638",
                           "locator" : "335:31-335:56",
                           "path" : "code",
                           "type" : "Property",
                           "source" : {
                              "localId" : "637",
                              "locator" : "335:31-335:51",
                              "name" : "observation-amended",
                              "type" : "CodeRef"
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "645",
                     "locator" : "336:10-336:58",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "642",
                        "locator" : "336:10-336:27",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "scope" : "observation",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "644",
                        "locator" : "336:31-336:58",
                        "path" : "code",
                        "type" : "Property",
                        "source" : {
                           "localId" : "643",
                           "locator" : "336:31-336:53",
                           "name" : "observation-corrected",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "627",
                  "locator" : "332:46-332:75",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "626",
                     "locator" : "332:51-332:74",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "655",
            "locator" : "338:1-339:47",
            "name" : "isFinal",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "655",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isFinal","(","observation"," " ]
                  }, {
                     "r" : "649",
                     "s" : [ {
                        "value" : [ "\"observation-bodyheight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "654",
                     "s" : [ {
                        "r" : "654",
                        "s" : [ {
                           "r" : "651",
                           "s" : [ {
                              "r" : "650",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "651",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "653",
                           "s" : [ {
                              "r" : "652",
                              "s" : [ {
                                 "value" : [ "\"observation-final\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "653",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "654",
               "locator" : "339:3-339:47",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "651",
                  "locator" : "339:3-339:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "650",
                        "locator" : "339:3-339:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "653",
                  "locator" : "339:24-339:47",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "652",
                     "locator" : "339:24-339:42",
                     "name" : "observation-final",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "649",
                  "locator" : "338:44-338:67",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "666",
            "locator" : "341:1-343:55",
            "name" : "final",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "666",
                  "s" : [ {
                     "value" : [ "","define fluent function ","final","(","observations"," " ]
                  }, {
                     "r" : "657",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "656",
                        "s" : [ {
                           "value" : [ "\"observation-bodyheight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "665",
                     "s" : [ {
                        "r" : "665",
                        "s" : [ {
                           "s" : [ {
                              "r" : "659",
                              "s" : [ {
                                 "r" : "658",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "664",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "664",
                              "s" : [ {
                                 "r" : "661",
                                 "s" : [ {
                                    "r" : "660",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "661",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "663",
                                 "s" : [ {
                                    "r" : "662",
                                    "s" : [ {
                                       "value" : [ "\"observation-final\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "663",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "665",
               "locator" : "342:3-343:55",
               "type" : "Query",
               "source" : [ {
                  "localId" : "659",
                  "locator" : "342:3-342:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "658",
                     "locator" : "342:3-342:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "664",
                  "locator" : "343:5-343:55",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "661",
                     "locator" : "343:11-343:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "663",
                     "locator" : "343:32-343:55",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "662",
                        "locator" : "343:32-343:50",
                        "name" : "observation-final",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "657",
                  "locator" : "341:43-341:72",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "656",
                     "locator" : "341:48-341:71",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "673",
            "locator" : "345:1-346:49",
            "name" : "isAmended",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "673",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isAmended","(","observation"," " ]
                  }, {
                     "r" : "667",
                     "s" : [ {
                        "value" : [ "\"observation-bodyheight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "672",
                     "s" : [ {
                        "r" : "672",
                        "s" : [ {
                           "r" : "669",
                           "s" : [ {
                              "r" : "668",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "669",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "671",
                           "s" : [ {
                              "r" : "670",
                              "s" : [ {
                                 "value" : [ "\"observation-amended\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "671",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "672",
               "locator" : "346:3-346:49",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "669",
                  "locator" : "346:3-346:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "668",
                        "locator" : "346:3-346:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "671",
                  "locator" : "346:24-346:49",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "670",
                     "locator" : "346:24-346:44",
                     "name" : "observation-amended",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "667",
                  "locator" : "345:46-345:69",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "684",
            "locator" : "348:1-350:57",
            "name" : "amended",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "684",
                  "s" : [ {
                     "value" : [ "","define fluent function ","amended","(","observations"," " ]
                  }, {
                     "r" : "675",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "674",
                        "s" : [ {
                           "value" : [ "\"observation-bodyheight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "683",
                     "s" : [ {
                        "r" : "683",
                        "s" : [ {
                           "s" : [ {
                              "r" : "677",
                              "s" : [ {
                                 "r" : "676",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "682",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "682",
                              "s" : [ {
                                 "r" : "679",
                                 "s" : [ {
                                    "r" : "678",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "679",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "681",
                                 "s" : [ {
                                    "r" : "680",
                                    "s" : [ {
                                       "value" : [ "\"observation-amended\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "681",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "683",
               "locator" : "349:3-350:57",
               "type" : "Query",
               "source" : [ {
                  "localId" : "677",
                  "locator" : "349:3-349:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "676",
                     "locator" : "349:3-349:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "682",
                  "locator" : "350:5-350:57",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "679",
                     "locator" : "350:11-350:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "681",
                     "locator" : "350:32-350:57",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "680",
                        "locator" : "350:32-350:52",
                        "name" : "observation-amended",
                        "type" : "CodeRef"
                     }
                  } ]
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "675",
                  "locator" : "348:45-348:74",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "674",
                     "locator" : "348:50-348:73",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "691",
            "locator" : "352:1-353:51",
            "name" : "isCorrected",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "691",
                  "s" : [ {
                     "value" : [ "","define fluent function ","isCorrected","(","observation"," " ]
                  }, {
                     "r" : "685",
                     "s" : [ {
                        "value" : [ "\"observation-bodyheight\"" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "690",
                     "s" : [ {
                        "r" : "690",
                        "s" : [ {
                           "r" : "687",
                           "s" : [ {
                              "r" : "686",
                              "s" : [ {
                                 "value" : [ "observation" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "687",
                              "s" : [ {
                                 "value" : [ "status" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " ","~"," " ]
                        }, {
                           "r" : "689",
                           "s" : [ {
                              "r" : "688",
                              "s" : [ {
                                 "value" : [ "\"observation-corrected\"" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "689",
                              "s" : [ {
                                 "value" : [ "code" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "690",
               "locator" : "353:3-353:51",
               "type" : "Equivalent",
               "operand" : [ {
                  "localId" : "687",
                  "locator" : "353:3-353:20",
                  "path" : "value",
                  "type" : "Property",
                  "source" : {
                     "path" : "status",
                     "type" : "Property",
                     "source" : {
                        "localId" : "686",
                        "locator" : "353:3-353:13",
                        "name" : "observation",
                        "type" : "OperandRef"
                     }
                  }
               }, {
                  "localId" : "689",
                  "locator" : "353:24-353:51",
                  "path" : "code",
                  "type" : "Property",
                  "source" : {
                     "localId" : "688",
                     "locator" : "353:24-353:46",
                     "name" : "observation-corrected",
                     "type" : "CodeRef"
                  }
               } ]
            },
            "operand" : [ {
               "name" : "observation",
               "operandTypeSpecifier" : {
                  "localId" : "685",
                  "locator" : "352:48-352:71",
                  "name" : "{http://hl7.org/fhir}Observation",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "705",
            "locator" : "355:1-358:29",
            "name" : "corrected",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "705",
                  "s" : [ {
                     "value" : [ "","define fluent function ","corrected","(","observations"," " ]
                  }, {
                     "r" : "693",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "692",
                        "s" : [ {
                           "value" : [ "\"observation-bodyheight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "704",
                     "s" : [ {
                        "r" : "704",
                        "s" : [ {
                           "s" : [ {
                              "r" : "695",
                              "s" : [ {
                                 "r" : "694",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "observations" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","observation" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "700",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "700",
                              "s" : [ {
                                 "r" : "697",
                                 "s" : [ {
                                    "r" : "696",
                                    "s" : [ {
                                       "value" : [ "observation" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "697",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "699",
                                 "s" : [ {
                                    "r" : "698",
                                    "s" : [ {
                                       "value" : [ "\"observation-corrected\"" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "699",
                                    "s" : [ {
                                       "value" : [ "code" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "703",
                           "s" : [ {
                              "value" : [ "return " ]
                           }, {
                              "r" : "702",
                              "s" : [ {
                                 "r" : "701",
                                 "s" : [ {
                                    "value" : [ "observation" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "702",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "704",
               "locator" : "356:3-358:29",
               "type" : "Query",
               "source" : [ {
                  "localId" : "695",
                  "locator" : "356:3-356:26",
                  "alias" : "observation",
                  "expression" : {
                     "localId" : "694",
                     "locator" : "356:3-356:14",
                     "name" : "observations",
                     "type" : "OperandRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "700",
                  "locator" : "357:5-357:59",
                  "type" : "Equivalent",
                  "operand" : [ {
                     "localId" : "697",
                     "locator" : "357:11-357:28",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "699",
                     "locator" : "357:32-357:59",
                     "path" : "code",
                     "type" : "Property",
                     "source" : {
                        "localId" : "698",
                        "locator" : "357:32-357:54",
                        "name" : "observation-corrected",
                        "type" : "CodeRef"
                     }
                  } ]
               },
               "return" : {
                  "localId" : "703",
                  "locator" : "358:5-358:29",
                  "expression" : {
                     "localId" : "702",
                     "locator" : "358:12-358:29",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "observation",
                        "type" : "Property"
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "693",
                  "locator" : "355:47-355:76",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "692",
                     "locator" : "355:52-355:75",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "714",
            "locator" : "363:1-366:3",
            "name" : "isCommunity",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given MedicationRequest has a category of Community"
               } ],
               "s" : {
                  "r" : "714",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given MedicationRequest has a category of Community\n*/\n","define fluent function ","isCommunity","(","medicationRequest"," " ]
                  }, {
                     "r" : "706",
                     "s" : [ {
                        "value" : [ "MedicationRequestProfile" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "713",
                     "s" : [ {
                        "r" : "713",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "712",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "712",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "708",
                                    "s" : [ {
                                       "r" : "707",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "medicationRequest",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "711",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "711",
                                    "s" : [ {
                                       "r" : "709",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "710",
                                       "s" : [ {
                                          "value" : [ "Community" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "713",
               "locator" : "364:3-366:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "712",
                  "locator" : "364:10-366:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "708",
                     "locator" : "364:11-364:38",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "707",
                        "locator" : "364:11-364:36",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "medicationRequest",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "711",
                     "locator" : "365:5-365:23",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "709",
                        "locator" : "365:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "710",
                           "locator" : "365:15-365:23",
                           "name" : "Community",
                           "type" : "CodeRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "medicationRequest",
               "operandTypeSpecifier" : {
                  "localId" : "706",
                  "locator" : "363:54-363:77",
                  "name" : "{http://hl7.org/fhir}MedicationRequest",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "723",
            "locator" : "371:1-374:3",
            "name" : "isDischarge",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given MedicationRequest has a category of Discharge"
               } ],
               "s" : {
                  "r" : "723",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given MedicationRequest has a category of Discharge\n*/\n","define fluent function ","isDischarge","(","medicationRequest"," " ]
                  }, {
                     "r" : "715",
                     "s" : [ {
                        "value" : [ "MedicationRequestProfile" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "722",
                     "s" : [ {
                        "r" : "722",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "721",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "721",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "717",
                                    "s" : [ {
                                       "r" : "716",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "medicationRequest",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "720",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "720",
                                    "s" : [ {
                                       "r" : "718",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "719",
                                       "s" : [ {
                                          "value" : [ "Discharge" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "722",
               "locator" : "372:3-374:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "721",
                  "locator" : "372:10-374:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "717",
                     "locator" : "372:11-372:38",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "716",
                        "locator" : "372:11-372:36",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "medicationRequest",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "720",
                     "locator" : "373:5-373:23",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "718",
                        "locator" : "373:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "719",
                           "locator" : "373:15-373:23",
                           "name" : "Discharge",
                           "type" : "CodeRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "medicationRequest",
               "operandTypeSpecifier" : {
                  "localId" : "715",
                  "locator" : "371:54-371:77",
                  "name" : "{http://hl7.org/fhir}MedicationRequest",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "733",
            "locator" : "379:1-382:3",
            "name" : "hasCategory",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns true if the given MedicationRequest has the given category"
               } ],
               "s" : {
                  "r" : "733",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns true if the given MedicationRequest has the given category\n*/\n","define fluent function ","hasCategory","(","medicationRequest"," " ]
                  }, {
                     "r" : "724",
                     "s" : [ {
                        "value" : [ "MedicationRequestProfile" ]
                     } ]
                  }, {
                     "value" : [ ", ","category"," " ]
                  }, {
                     "r" : "725",
                     "s" : [ {
                        "value" : [ "Code" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "732",
                     "s" : [ {
                        "r" : "732",
                        "s" : [ {
                           "value" : [ "exists " ]
                        }, {
                           "r" : "731",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "731",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "727",
                                    "s" : [ {
                                       "r" : "726",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "medicationRequest",".","category" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","C" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n    " ]
                              }, {
                                 "r" : "730",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "730",
                                    "s" : [ {
                                       "r" : "728",
                                       "s" : [ {
                                          "value" : [ "C" ]
                                       } ]
                                    }, {
                                       "value" : [ " ","~"," " ]
                                    }, {
                                       "r" : "729",
                                       "s" : [ {
                                          "value" : [ "category" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "732",
               "locator" : "380:3-382:3",
               "type" : "Exists",
               "operand" : {
                  "localId" : "731",
                  "locator" : "380:10-382:3",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "727",
                     "locator" : "380:11-380:38",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "726",
                        "locator" : "380:11-380:36",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "category",
                              "type" : "Property",
                              "source" : {
                                 "name" : "medicationRequest",
                                 "type" : "OperandRef"
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToConcept",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "730",
                     "locator" : "381:5-381:22",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "728",
                        "locator" : "381:11",
                        "name" : "C",
                        "type" : "AliasRef"
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "729",
                           "locator" : "381:15-381:22",
                           "name" : "category",
                           "type" : "OperandRef"
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "medicationRequest",
               "operandTypeSpecifier" : {
                  "localId" : "724",
                  "locator" : "379:54-379:77",
                  "name" : "{http://hl7.org/fhir}MedicationRequest",
                  "type" : "NamedTypeSpecifier"
               }
            }, {
               "name" : "category",
               "operandTypeSpecifier" : {
                  "localId" : "725",
                  "locator" : "379:89-379:92",
                  "name" : "{urn:hl7-org:elm-types:r1}Code",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "807",
            "locator" : "404:1-418:4",
            "name" : "toInterval",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Normalizes a value that is a choice of timing-valued types to an equivalent interval"
               }, {
                  "name" : "comment",
                  "value" : "Normalizes a choice type of DateTime, Quanitty, Interval<DateTime>, or Interval<Quantity> types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval<DateTime> or Interval<Quantity>.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nAny other input will reslt in a null DateTime Interval"
               } ],
               "s" : {
                  "r" : "807",
                  "s" : [ {
                     "value" : [ "/*\n@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval\n@comment: Normalizes a choice type of DateTime, Quanitty, Interval<DateTime>, or Interval<Quantity> types\nto an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible\nrepresentations for timing-valued elements in QICore, allowing this function to be used across any resource.\nThe input can be provided as a DateTime, Quantity, Interval<DateTime> or Interval<Quantity>.\nThe intent of this function is to provide a clear and concise mechanism to treat single\nelements that have multiple possible representations as intervals so that logic doesn't have to account\nfor the variability. More complex calculations (such as medication request period or dispense period\ncalculation) need specific guidance and consideration. That guidance may make use of this function, but\nthe focus of this function is on single element calculations where the semantics are unambiguous.\nIf the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.\nIf the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,\nand the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.\nIf the input is a DateTime Interval, the result is the input.\nIf the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result\nis a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending\nimmediately before one year later than the date the patient turned the age given as the end of the quantity interval.\nAny other input will reslt in a null DateTime Interval\n*/\n","define fluent function ","toInterval","(","choice"," " ]
                  }, {
                     "r" : "740",
                     "s" : [ {
                        "value" : [ "Choice<" ]
                     }, {
                        "r" : "734",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "735",
                        "s" : [ {
                           "value" : [ "Quantity" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "737",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "736",
                           "s" : [ {
                              "value" : [ "DateTime" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "739",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "738",
                           "s" : [ {
                              "value" : [ "Quantity" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "806",
                     "s" : [ {
                        "r" : "806",
                        "s" : [ {
                           "value" : [ "case\n\t  " ]
                        }, {
                           "r" : "751",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "743",
                              "s" : [ {
                                 "r" : "741",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "742",
                                 "s" : [ {
                                    "value" : [ "DateTime" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\n    \t" ]
                           }, {
                              "r" : "750",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "746",
                                 "s" : [ {
                                    "r" : "744",
                                    "s" : [ {
                                       "value" : [ "choice" ]
                                    } ]
                                 }, {
                                    "value" : [ " as " ]
                                 }, {
                                    "r" : "745",
                                    "s" : [ {
                                       "value" : [ "DateTime" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "749",
                                 "s" : [ {
                                    "r" : "747",
                                    "s" : [ {
                                       "value" : [ "choice" ]
                                    } ]
                                 }, {
                                    "value" : [ " as " ]
                                 }, {
                                    "r" : "748",
                                    "s" : [ {
                                       "value" : [ "DateTime" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "]" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n\t\t" ]
                        }, {
                           "r" : "760",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "755",
                              "s" : [ {
                                 "r" : "752",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "754",
                                 "s" : [ {
                                    "value" : [ "Interval<" ]
                                 }, {
                                    "r" : "753",
                                    "s" : [ {
                                       "value" : [ "DateTime" ]
                                    } ]
                                 }, {
                                    "value" : [ ">" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\n  \t\t" ]
                           }, {
                              "r" : "759",
                              "s" : [ {
                                 "r" : "756",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " as " ]
                              }, {
                                 "r" : "758",
                                 "s" : [ {
                                    "value" : [ "Interval<" ]
                                 }, {
                                    "r" : "757",
                                    "s" : [ {
                                       "value" : [ "DateTime" ]
                                    } ]
                                 }, {
                                    "value" : [ ">" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n\t\t" ]
                        }, {
                           "r" : "779",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "763",
                              "s" : [ {
                                 "r" : "761",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "762",
                                 "s" : [ {
                                    "value" : [ "Quantity" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\n\t\t  " ]
                           }, {
                              "r" : "778",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "769",
                                 "s" : [ {
                                    "r" : "765",
                                    "s" : [ {
                                       "r" : "764",
                                       "s" : [ {
                                          "value" : [ "Patient" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "765",
                                       "s" : [ {
                                          "value" : [ "birthDate" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "768",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "768",
                                       "s" : [ {
                                          "r" : "766",
                                          "s" : [ {
                                             "value" : [ "choice" ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "767",
                                          "s" : [ {
                                             "value" : [ "Quantity" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\n\t\t\t  " ]
                              }, {
                                 "r" : "777",
                                 "s" : [ {
                                    "r" : "775",
                                    "s" : [ {
                                       "r" : "771",
                                       "s" : [ {
                                          "r" : "770",
                                          "s" : [ {
                                             "value" : [ "Patient" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "771",
                                          "s" : [ {
                                             "value" : [ "birthDate" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "774",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "774",
                                          "s" : [ {
                                             "r" : "772",
                                             "s" : [ {
                                                "value" : [ "choice" ]
                                             } ]
                                          }, {
                                             "value" : [ " as " ]
                                          }, {
                                             "r" : "773",
                                             "s" : [ {
                                                "value" : [ "Quantity" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "776",
                                    "s" : [ {
                                       "value" : [ "1 ","year" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n\t\t" ]
                        }, {
                           "r" : "801",
                           "s" : [ {
                              "value" : [ "when " ]
                           }, {
                              "r" : "783",
                              "s" : [ {
                                 "r" : "780",
                                 "s" : [ {
                                    "value" : [ "choice" ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "782",
                                 "s" : [ {
                                    "value" : [ "Interval<" ]
                                 }, {
                                    "r" : "781",
                                    "s" : [ {
                                       "value" : [ "Quantity" ]
                                    } ]
                                 }, {
                                    "value" : [ ">" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\n\t\t  " ]
                           }, {
                              "r" : "800",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "790",
                                 "s" : [ {
                                    "r" : "785",
                                    "s" : [ {
                                       "r" : "784",
                                       "s" : [ {
                                          "value" : [ "Patient" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "785",
                                       "s" : [ {
                                          "value" : [ "birthDate" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "789",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "789",
                                       "s" : [ {
                                          "r" : "787",
                                          "s" : [ {
                                             "r" : "786",
                                             "s" : [ {
                                                "value" : [ "choice" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "787",
                                             "s" : [ {
                                                "value" : [ "low" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "788",
                                          "s" : [ {
                                             "value" : [ "Quantity" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\n\t\t\t  " ]
                              }, {
                                 "r" : "799",
                                 "s" : [ {
                                    "r" : "797",
                                    "s" : [ {
                                       "r" : "792",
                                       "s" : [ {
                                          "r" : "791",
                                          "s" : [ {
                                             "value" : [ "Patient" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "792",
                                          "s" : [ {
                                             "value" : [ "birthDate" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "796",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "796",
                                          "s" : [ {
                                             "r" : "794",
                                             "s" : [ {
                                                "r" : "793",
                                                "s" : [ {
                                                   "value" : [ "choice" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "794",
                                                "s" : [ {
                                                   "value" : [ "high" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " as " ]
                                          }, {
                                             "r" : "795",
                                             "s" : [ {
                                                "value" : [ "Quantity" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "798",
                                    "s" : [ {
                                       "value" : [ "1 ","year" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n\t\telse\n\t\t\t" ]
                        }, {
                           "r" : "805",
                           "s" : [ {
                              "r" : "802",
                              "value" : [ "null"," as " ]
                           }, {
                              "r" : "804",
                              "s" : [ {
                                 "value" : [ "Interval<" ]
                              }, {
                                 "r" : "803",
                                 "s" : [ {
                                    "value" : [ "DateTime" ]
                                 } ]
                              }, {
                                 "value" : [ ">" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n\tend" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "806",
               "locator" : "405:3-418:4",
               "type" : "Case",
               "caseItem" : [ {
                  "localId" : "751",
                  "locator" : "406:4-407:53",
                  "when" : {
                     "localId" : "743",
                     "locator" : "406:9-406:26",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "741",
                        "locator" : "406:9-406:14",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "742",
                        "locator" : "406:19-406:26",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "localId" : "750",
                     "locator" : "407:6-407:53",
                     "lowClosed" : true,
                     "highClosed" : true,
                     "type" : "Interval",
                     "low" : {
                        "localId" : "746",
                        "locator" : "407:15-407:32",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "744",
                           "locator" : "407:15-407:20",
                           "name" : "choice",
                           "type" : "OperandRef"
                        },
                        "asTypeSpecifier" : {
                           "localId" : "745",
                           "locator" : "407:25-407:32",
                           "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     },
                     "high" : {
                        "localId" : "749",
                        "locator" : "407:35-407:52",
                        "strict" : false,
                        "type" : "As",
                        "operand" : {
                           "localId" : "747",
                           "locator" : "407:35-407:40",
                           "name" : "choice",
                           "type" : "OperandRef"
                        },
                        "asTypeSpecifier" : {
                           "localId" : "748",
                           "locator" : "407:45-407:52",
                           "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     }
                  }
               }, {
                  "localId" : "760",
                  "locator" : "408:3-409:32",
                  "when" : {
                     "localId" : "755",
                     "locator" : "408:8-408:35",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "752",
                        "locator" : "408:8-408:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "754",
                        "locator" : "408:18-408:35",
                        "type" : "IntervalTypeSpecifier",
                        "pointType" : {
                           "localId" : "753",
                           "locator" : "408:27-408:34",
                           "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     }
                  },
                  "then" : {
                     "localId" : "759",
                     "locator" : "409:5-409:32",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "756",
                        "locator" : "409:5-409:10",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "asTypeSpecifier" : {
                        "localId" : "758",
                        "locator" : "409:15-409:32",
                        "type" : "IntervalTypeSpecifier",
                        "pointType" : {
                           "localId" : "757",
                           "locator" : "409:24-409:31",
                           "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                           "type" : "NamedTypeSpecifier"
                        }
                     }
                  }
               }, {
                  "localId" : "779",
                  "locator" : "410:3-412:55",
                  "when" : {
                     "localId" : "763",
                     "locator" : "410:8-410:25",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "761",
                        "locator" : "410:8-410:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "762",
                        "locator" : "410:18-410:25",
                        "name" : "{http://hl7.org/fhir}Quantity",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "then" : {
                     "type" : "Interval",
                     "low" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "low",
                           "type" : "Property",
                           "source" : {
                              "localId" : "778",
                              "locator" : "411:5-412:55",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "769",
                                 "locator" : "411:14-411:53",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "765",
                                    "locator" : "411:14-411:30",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "764",
                                          "locator" : "411:14-411:20",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "768",
                                       "locator" : "411:34-411:53",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "766",
                                          "locator" : "411:35-411:40",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "767",
                                          "locator" : "411:45-411:52",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "777",
                                 "locator" : "412:6-412:54",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "775",
                                    "locator" : "412:6-412:45",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "771",
                                       "locator" : "412:6-412:22",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "770",
                                             "locator" : "412:6-412:12",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "774",
                                          "locator" : "412:26-412:45",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "772",
                                             "locator" : "412:27-412:32",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "773",
                                             "locator" : "412:37-412:44",
                                             "name" : "{http://hl7.org/fhir}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "776",
                                    "locator" : "412:49-412:54",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "lowClosedExpression" : {
                        "path" : "lowClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "778",
                           "locator" : "411:5-412:55",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "769",
                              "locator" : "411:14-411:53",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "765",
                                 "locator" : "411:14-411:30",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "764",
                                       "locator" : "411:14-411:20",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 }
                              }, {
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "768",
                                    "locator" : "411:34-411:53",
                                    "strict" : false,
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "766",
                                       "locator" : "411:35-411:40",
                                       "name" : "choice",
                                       "type" : "OperandRef"
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "767",
                                       "locator" : "411:45-411:52",
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "777",
                              "locator" : "412:6-412:54",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "775",
                                 "locator" : "412:6-412:45",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "771",
                                    "locator" : "412:6-412:22",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "770",
                                          "locator" : "412:6-412:12",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "774",
                                       "locator" : "412:26-412:45",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "772",
                                          "locator" : "412:27-412:32",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "773",
                                          "locator" : "412:37-412:44",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "776",
                                 "locator" : "412:49-412:54",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     },
                     "high" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "high",
                           "type" : "Property",
                           "source" : {
                              "localId" : "778",
                              "locator" : "411:5-412:55",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "769",
                                 "locator" : "411:14-411:53",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "765",
                                    "locator" : "411:14-411:30",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "764",
                                          "locator" : "411:14-411:20",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "768",
                                       "locator" : "411:34-411:53",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "766",
                                          "locator" : "411:35-411:40",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "767",
                                          "locator" : "411:45-411:52",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "777",
                                 "locator" : "412:6-412:54",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "775",
                                    "locator" : "412:6-412:45",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "771",
                                       "locator" : "412:6-412:22",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "770",
                                             "locator" : "412:6-412:12",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "774",
                                          "locator" : "412:26-412:45",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "772",
                                             "locator" : "412:27-412:32",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "773",
                                             "locator" : "412:37-412:44",
                                             "name" : "{http://hl7.org/fhir}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "776",
                                    "locator" : "412:49-412:54",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "highClosedExpression" : {
                        "path" : "highClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "778",
                           "locator" : "411:5-412:55",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "769",
                              "locator" : "411:14-411:53",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "765",
                                 "locator" : "411:14-411:30",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "764",
                                       "locator" : "411:14-411:20",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 }
                              }, {
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "768",
                                    "locator" : "411:34-411:53",
                                    "strict" : false,
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "766",
                                       "locator" : "411:35-411:40",
                                       "name" : "choice",
                                       "type" : "OperandRef"
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "767",
                                       "locator" : "411:45-411:52",
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "777",
                              "locator" : "412:6-412:54",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "775",
                                 "locator" : "412:6-412:45",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "771",
                                    "locator" : "412:6-412:22",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "770",
                                          "locator" : "412:6-412:12",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "774",
                                       "locator" : "412:26-412:45",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "772",
                                          "locator" : "412:27-412:32",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "773",
                                          "locator" : "412:37-412:44",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "776",
                                 "locator" : "412:49-412:54",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     }
                  }
               }, {
                  "localId" : "801",
                  "locator" : "413:3-415:60",
                  "when" : {
                     "localId" : "783",
                     "locator" : "413:8-413:35",
                     "type" : "Is",
                     "operand" : {
                        "localId" : "780",
                        "locator" : "413:8-413:13",
                        "name" : "choice",
                        "type" : "OperandRef"
                     },
                     "isTypeSpecifier" : {
                        "localId" : "782",
                        "locator" : "413:18-413:35",
                        "type" : "IntervalTypeSpecifier",
                        "pointType" : {
                           "localId" : "781",
                           "locator" : "413:27-413:34",
                           "name" : "{http://hl7.org/fhir}Quantity",
                           "type" : "NamedTypeSpecifier"
                        }
                     }
                  },
                  "then" : {
                     "type" : "Interval",
                     "low" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "low",
                           "type" : "Property",
                           "source" : {
                              "localId" : "800",
                              "locator" : "414:5-415:60",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "790",
                                 "locator" : "414:14-414:57",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "785",
                                    "locator" : "414:14-414:30",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "784",
                                          "locator" : "414:14-414:20",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "789",
                                       "locator" : "414:34-414:57",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "787",
                                          "locator" : "414:35-414:44",
                                          "path" : "low",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "786",
                                             "locator" : "414:35-414:40",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "788",
                                          "locator" : "414:49-414:56",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "799",
                                 "locator" : "415:6-415:59",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "797",
                                    "locator" : "415:6-415:50",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "792",
                                       "locator" : "415:6-415:22",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "791",
                                             "locator" : "415:6-415:12",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "796",
                                          "locator" : "415:26-415:50",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "794",
                                             "locator" : "415:27-415:37",
                                             "path" : "high",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "793",
                                                "locator" : "415:27-415:32",
                                                "name" : "choice",
                                                "type" : "OperandRef"
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "795",
                                             "locator" : "415:42-415:49",
                                             "name" : "{http://hl7.org/fhir}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "798",
                                    "locator" : "415:54-415:59",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "lowClosedExpression" : {
                        "path" : "lowClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "800",
                           "locator" : "414:5-415:60",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "790",
                              "locator" : "414:14-414:57",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "785",
                                 "locator" : "414:14-414:30",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "784",
                                       "locator" : "414:14-414:20",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 }
                              }, {
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "789",
                                    "locator" : "414:34-414:57",
                                    "strict" : false,
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "787",
                                       "locator" : "414:35-414:44",
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "786",
                                          "locator" : "414:35-414:40",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "788",
                                       "locator" : "414:49-414:56",
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "799",
                              "locator" : "415:6-415:59",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "797",
                                 "locator" : "415:6-415:50",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "792",
                                    "locator" : "415:6-415:22",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "791",
                                          "locator" : "415:6-415:12",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "796",
                                       "locator" : "415:26-415:50",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "794",
                                          "locator" : "415:27-415:37",
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "793",
                                             "locator" : "415:27-415:32",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "795",
                                          "locator" : "415:42-415:49",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "798",
                                 "locator" : "415:54-415:59",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     },
                     "high" : {
                        "type" : "ToDateTime",
                        "operand" : {
                           "path" : "high",
                           "type" : "Property",
                           "source" : {
                              "localId" : "800",
                              "locator" : "414:5-415:60",
                              "lowClosed" : true,
                              "highClosed" : false,
                              "type" : "Interval",
                              "low" : {
                                 "localId" : "790",
                                 "locator" : "414:14-414:57",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "785",
                                    "locator" : "414:14-414:30",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "784",
                                          "locator" : "414:14-414:20",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "789",
                                       "locator" : "414:34-414:57",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "787",
                                          "locator" : "414:35-414:44",
                                          "path" : "low",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "786",
                                             "locator" : "414:35-414:40",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "788",
                                          "locator" : "414:49-414:56",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              },
                              "high" : {
                                 "localId" : "799",
                                 "locator" : "415:6-415:59",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "797",
                                    "locator" : "415:6-415:50",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "792",
                                       "locator" : "415:6-415:22",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "791",
                                             "locator" : "415:6-415:12",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "name" : "ToQuantity",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "localId" : "796",
                                          "locator" : "415:26-415:50",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "794",
                                             "locator" : "415:27-415:37",
                                             "path" : "high",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "793",
                                                "locator" : "415:27-415:32",
                                                "name" : "choice",
                                                "type" : "OperandRef"
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "795",
                                             "locator" : "415:42-415:49",
                                             "name" : "{http://hl7.org/fhir}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    } ]
                                 }, {
                                    "localId" : "798",
                                    "locator" : "415:54-415:59",
                                    "value" : 1,
                                    "unit" : "year",
                                    "type" : "Quantity"
                                 } ]
                              }
                           }
                        }
                     },
                     "highClosedExpression" : {
                        "path" : "highClosed",
                        "type" : "Property",
                        "source" : {
                           "localId" : "800",
                           "locator" : "414:5-415:60",
                           "lowClosed" : true,
                           "highClosed" : false,
                           "type" : "Interval",
                           "low" : {
                              "localId" : "790",
                              "locator" : "414:14-414:57",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "785",
                                 "locator" : "414:14-414:30",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "path" : "birthDate",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "784",
                                       "locator" : "414:14-414:20",
                                       "name" : "Patient",
                                       "type" : "ExpressionRef"
                                    }
                                 }
                              }, {
                                 "name" : "ToQuantity",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "localId" : "789",
                                    "locator" : "414:34-414:57",
                                    "strict" : false,
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "787",
                                       "locator" : "414:35-414:44",
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "786",
                                          "locator" : "414:35-414:40",
                                          "name" : "choice",
                                          "type" : "OperandRef"
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "localId" : "788",
                                       "locator" : "414:49-414:56",
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              } ]
                           },
                           "high" : {
                              "localId" : "799",
                              "locator" : "415:6-415:59",
                              "type" : "Add",
                              "operand" : [ {
                                 "localId" : "797",
                                 "locator" : "415:6-415:50",
                                 "type" : "Add",
                                 "operand" : [ {
                                    "localId" : "792",
                                    "locator" : "415:6-415:22",
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "path" : "birthDate",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "791",
                                          "locator" : "415:6-415:12",
                                          "name" : "Patient",
                                          "type" : "ExpressionRef"
                                       }
                                    }
                                 }, {
                                    "name" : "ToQuantity",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "localId" : "796",
                                       "locator" : "415:26-415:50",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "794",
                                          "locator" : "415:27-415:37",
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "793",
                                             "locator" : "415:27-415:32",
                                             "name" : "choice",
                                             "type" : "OperandRef"
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "795",
                                          "locator" : "415:42-415:49",
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 } ]
                              }, {
                                 "localId" : "798",
                                 "locator" : "415:54-415:59",
                                 "value" : 1,
                                 "unit" : "year",
                                 "type" : "Quantity"
                              } ]
                           }
                        }
                     }
                  }
               } ],
               "else" : {
                  "localId" : "805",
                  "locator" : "417:4-417:29",
                  "strict" : false,
                  "type" : "As",
                  "operand" : {
                     "localId" : "802",
                     "locator" : "417:4-417:7",
                     "type" : "Null"
                  },
                  "asTypeSpecifier" : {
                     "localId" : "804",
                     "locator" : "417:12-417:29",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "803",
                        "locator" : "417:21-417:28",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "choice",
               "operandTypeSpecifier" : {
                  "localId" : "740",
                  "locator" : "404:42-404:107",
                  "type" : "ChoiceTypeSpecifier",
                  "choice" : [ {
                     "localId" : "734",
                     "locator" : "404:49-404:56",
                     "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "735",
                     "locator" : "404:59-404:66",
                     "name" : "{http://hl7.org/fhir}Quantity",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "737",
                     "locator" : "404:69-404:86",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "736",
                        "locator" : "404:78-404:85",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }, {
                     "localId" : "739",
                     "locator" : "404:89-404:106",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "738",
                        "locator" : "404:98-404:105",
                        "name" : "{http://hl7.org/fhir}Quantity",
                        "type" : "NamedTypeSpecifier"
                     }
                  } ]
               }
            } ]
         }, {
            "localId" : "887",
            "locator" : "430:1-441:32",
            "name" : "abatementInterval",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns an interval representing the normalized abatement of a given Condition."
               }, {
                  "name" : "comment",
                  "value" : "If the abatement element of the Condition is represented as a DateTime, the result\nis an interval beginning and ending on that DateTime.\nIf the abatement is represented as a Quantity, the quantity is expected to be a calendar-duration and is interpreted as the age of the patient. The\nresult is an interval from the date the patient turned that age to immediately before one year later.\nIf the abatement is represented as a Quantity Interval, the quantities are expected to be calendar-durations and are interpreted as an age range during\nwhich the abatement occurred. The result is an interval from the date the patient turned the starting age of the quantity interval, and ending immediately\nbefore one year later than the date the patient turned the ending age of the quantity interval."
               } ],
               "s" : {
                  "r" : "887",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns an interval representing the normalized abatement of a given Condition.\n@comment: If the abatement element of the Condition is represented as a DateTime, the result\nis an interval beginning and ending on that DateTime.\nIf the abatement is represented as a Quantity, the quantity is expected to be a calendar-duration and is interpreted as the age of the patient. The\nresult is an interval from the date the patient turned that age to immediately before one year later.\nIf the abatement is represented as a Quantity Interval, the quantities are expected to be calendar-durations and are interpreted as an age range during\nwhich the abatement occurred. The result is an interval from the date the patient turned the starting age of the quantity interval, and ending immediately\nbefore one year later than the date the patient turned the ending age of the quantity interval.\n*/\n","define fluent function ","abatementInterval","(","condition"," " ]
                  }, {
                     "r" : "808",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n\t" ]
                  }, {
                     "r" : "886",
                     "s" : [ {
                        "r" : "886",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "812",
                           "s" : [ {
                              "r" : "810",
                              "s" : [ {
                                 "r" : "809",
                                 "s" : [ {
                                    "value" : [ "condition" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "810",
                                 "s" : [ {
                                    "value" : [ "abatement" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " is " ]
                           }, {
                              "r" : "811",
                              "s" : [ {
                                 "value" : [ "DateTime" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " then\n\t  " ]
                        }, {
                           "r" : "821",
                           "s" : [ {
                              "value" : [ "Interval[" ]
                           }, {
                              "r" : "816",
                              "s" : [ {
                                 "r" : "814",
                                 "s" : [ {
                                    "r" : "813",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "814",
                                    "s" : [ {
                                       "value" : [ "abatement" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " as " ]
                              }, {
                                 "r" : "815",
                                 "s" : [ {
                                    "value" : [ "DateTime" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "820",
                              "s" : [ {
                                 "r" : "818",
                                 "s" : [ {
                                    "r" : "817",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "818",
                                    "s" : [ {
                                       "value" : [ "abatement" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " as " ]
                              }, {
                                 "r" : "819",
                                 "s" : [ {
                                    "value" : [ "DateTime" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "]" ]
                           } ]
                        }, {
                           "value" : [ "\n\telse " ]
                        }, {
                           "r" : "885",
                           "s" : [ {
                              "value" : [ "if " ]
                           }, {
                              "r" : "825",
                              "s" : [ {
                                 "r" : "823",
                                 "s" : [ {
                                    "r" : "822",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "823",
                                    "s" : [ {
                                       "value" : [ "abatement" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is " ]
                              }, {
                                 "r" : "824",
                                 "s" : [ {
                                    "value" : [ "System",".","Quantity" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " then\n\t\t" ]
                           }, {
                              "r" : "842",
                              "s" : [ {
                                 "value" : [ "Interval[" ]
                              }, {
                                 "r" : "832",
                                 "s" : [ {
                                    "r" : "827",
                                    "s" : [ {
                                       "r" : "826",
                                       "s" : [ {
                                          "value" : [ "Patient" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "827",
                                       "s" : [ {
                                          "value" : [ "birthDate" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "831",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "831",
                                       "s" : [ {
                                          "r" : "829",
                                          "s" : [ {
                                             "r" : "828",
                                             "s" : [ {
                                                "value" : [ "condition" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "829",
                                             "s" : [ {
                                                "value" : [ "abatement" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "830",
                                          "s" : [ {
                                             "value" : [ "System",".","Quantity" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ",\n\t\t\t" ]
                              }, {
                                 "r" : "841",
                                 "s" : [ {
                                    "r" : "839",
                                    "s" : [ {
                                       "r" : "834",
                                       "s" : [ {
                                          "r" : "833",
                                          "s" : [ {
                                             "value" : [ "Patient" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "834",
                                          "s" : [ {
                                             "value" : [ "birthDate" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "838",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "838",
                                          "s" : [ {
                                             "r" : "836",
                                             "s" : [ {
                                                "r" : "835",
                                                "s" : [ {
                                                   "value" : [ "condition" ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "836",
                                                "s" : [ {
                                                   "value" : [ "abatement" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " as " ]
                                          }, {
                                             "r" : "837",
                                             "s" : [ {
                                                "value" : [ "System",".","Quantity" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " + " ]
                                 }, {
                                    "r" : "840",
                                    "s" : [ {
                                       "value" : [ "1 ","year" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ ")" ]
                              } ]
                           }, {
                              "value" : [ "\n\telse " ]
                           }, {
                              "r" : "884",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "847",
                                 "s" : [ {
                                    "r" : "844",
                                    "s" : [ {
                                       "r" : "843",
                                       "s" : [ {
                                          "value" : [ "condition" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "844",
                                       "s" : [ {
                                          "value" : [ "abatement" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " is " ]
                                 }, {
                                    "r" : "846",
                                    "s" : [ {
                                       "value" : [ "Interval<" ]
                                    }, {
                                       "r" : "845",
                                       "s" : [ {
                                          "value" : [ "System",".","Quantity" ]
                                       } ]
                                    }, {
                                       "value" : [ ">" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " then\n\t  " ]
                              }, {
                                 "r" : "866",
                                 "s" : [ {
                                    "value" : [ "Interval[" ]
                                 }, {
                                    "r" : "855",
                                    "s" : [ {
                                       "r" : "849",
                                       "s" : [ {
                                          "r" : "848",
                                          "s" : [ {
                                             "value" : [ "Patient" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "849",
                                          "s" : [ {
                                             "value" : [ "birthDate" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "854",
                                       "s" : [ {
                                          "value" : [ "(" ]
                                       }, {
                                          "r" : "854",
                                          "s" : [ {
                                             "r" : "852",
                                             "s" : [ {
                                                "r" : "851",
                                                "s" : [ {
                                                   "r" : "850",
                                                   "s" : [ {
                                                      "value" : [ "condition" ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "851",
                                                   "s" : [ {
                                                      "value" : [ "abatement" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ "." ]
                                             }, {
                                                "r" : "852",
                                                "s" : [ {
                                                   "value" : [ "low" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ " as " ]
                                          }, {
                                             "r" : "853",
                                             "s" : [ {
                                                "value" : [ "System",".","Quantity" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ ")" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ",\n\t\t  " ]
                                 }, {
                                    "r" : "865",
                                    "s" : [ {
                                       "r" : "863",
                                       "s" : [ {
                                          "r" : "857",
                                          "s" : [ {
                                             "r" : "856",
                                             "s" : [ {
                                                "value" : [ "Patient" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "857",
                                             "s" : [ {
                                                "value" : [ "birthDate" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " + " ]
                                       }, {
                                          "r" : "862",
                                          "s" : [ {
                                             "value" : [ "(" ]
                                          }, {
                                             "r" : "862",
                                             "s" : [ {
                                                "r" : "860",
                                                "s" : [ {
                                                   "r" : "859",
                                                   "s" : [ {
                                                      "r" : "858",
                                                      "s" : [ {
                                                         "value" : [ "condition" ]
                                                      } ]
                                                   }, {
                                                      "value" : [ "." ]
                                                   }, {
                                                      "r" : "859",
                                                      "s" : [ {
                                                         "value" : [ "abatement" ]
                                                      } ]
                                                   } ]
                                                }, {
                                                   "value" : [ "." ]
                                                }, {
                                                   "r" : "860",
                                                   "s" : [ {
                                                      "value" : [ "high" ]
                                                   } ]
                                                } ]
                                             }, {
                                                "value" : [ " as " ]
                                             }, {
                                                "r" : "861",
                                                "s" : [ {
                                                   "value" : [ "System",".","Quantity" ]
                                                } ]
                                             } ]
                                          }, {
                                             "value" : [ ")" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " + " ]
                                    }, {
                                       "r" : "864",
                                       "s" : [ {
                                          "value" : [ "1 ","year" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ "\n\telse " ]
                              }, {
                                 "r" : "883",
                                 "s" : [ {
                                    "value" : [ "if " ]
                                 }, {
                                    "r" : "871",
                                    "s" : [ {
                                       "r" : "868",
                                       "s" : [ {
                                          "r" : "867",
                                          "s" : [ {
                                             "value" : [ "condition" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "868",
                                          "s" : [ {
                                             "value" : [ "abatement" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " is " ]
                                    }, {
                                       "r" : "870",
                                       "s" : [ {
                                          "value" : [ "Interval<" ]
                                       }, {
                                          "r" : "869",
                                          "s" : [ {
                                             "value" : [ "DateTime" ]
                                          } ]
                                       }, {
                                          "value" : [ ">" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " then\n\t  " ]
                                 }, {
                                    "r" : "878",
                                    "s" : [ {
                                       "value" : [ "Interval[" ]
                                    }, {
                                       "r" : "874",
                                       "s" : [ {
                                          "r" : "873",
                                          "s" : [ {
                                             "r" : "872",
                                             "s" : [ {
                                                "value" : [ "condition" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "873",
                                             "s" : [ {
                                                "value" : [ "abatement" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "874",
                                          "s" : [ {
                                             "value" : [ "low" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ", " ]
                                    }, {
                                       "r" : "877",
                                       "s" : [ {
                                          "r" : "876",
                                          "s" : [ {
                                             "r" : "875",
                                             "s" : [ {
                                                "value" : [ "condition" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "876",
                                             "s" : [ {
                                                "value" : [ "abatement" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "877",
                                          "s" : [ {
                                             "value" : [ "high" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 }, {
                                    "value" : [ "\n\telse " ]
                                 }, {
                                    "r" : "882",
                                    "s" : [ {
                                       "r" : "879",
                                       "value" : [ "null"," as " ]
                                    }, {
                                       "r" : "881",
                                       "s" : [ {
                                          "value" : [ "Interval<" ]
                                       }, {
                                          "r" : "880",
                                          "s" : [ {
                                             "value" : [ "DateTime" ]
                                          } ]
                                       }, {
                                          "value" : [ ">" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "886",
               "locator" : "431:2-441:32",
               "type" : "If",
               "condition" : {
                  "localId" : "812",
                  "locator" : "431:5-431:35",
                  "type" : "Is",
                  "operand" : {
                     "localId" : "810",
                     "locator" : "431:5-431:23",
                     "name" : "ToValue",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "abatement",
                        "type" : "Property",
                        "source" : {
                           "localId" : "809",
                           "locator" : "431:5-431:13",
                           "name" : "condition",
                           "type" : "OperandRef"
                        }
                     } ]
                  },
                  "isTypeSpecifier" : {
                     "localId" : "811",
                     "locator" : "431:28-431:35",
                     "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "NamedTypeSpecifier"
                  }
               },
               "then" : {
                  "localId" : "821",
                  "locator" : "432:4-432:77",
                  "lowClosed" : true,
                  "highClosed" : true,
                  "type" : "Interval",
                  "low" : {
                     "localId" : "816",
                     "locator" : "432:13-432:43",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "814",
                        "locator" : "432:13-432:31",
                        "name" : "ToValue",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "abatement",
                           "type" : "Property",
                           "source" : {
                              "localId" : "813",
                              "locator" : "432:13-432:21",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        } ]
                     },
                     "asTypeSpecifier" : {
                        "localId" : "815",
                        "locator" : "432:36-432:43",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  },
                  "high" : {
                     "localId" : "820",
                     "locator" : "432:46-432:76",
                     "strict" : false,
                     "type" : "As",
                     "operand" : {
                        "localId" : "818",
                        "locator" : "432:46-432:64",
                        "name" : "ToValue",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "abatement",
                           "type" : "Property",
                           "source" : {
                              "localId" : "817",
                              "locator" : "432:46-432:54",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        } ]
                     },
                     "asTypeSpecifier" : {
                        "localId" : "819",
                        "locator" : "432:69-432:76",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }
               },
               "else" : {
                  "type" : "Interval",
                  "low" : {
                     "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "As",
                     "operand" : {
                        "path" : "low",
                        "type" : "Property",
                        "source" : {
                           "localId" : "885",
                           "locator" : "433:7-441:32",
                           "type" : "If",
                           "condition" : {
                              "localId" : "825",
                              "locator" : "433:10-433:47",
                              "type" : "Is",
                              "operand" : {
                                 "localId" : "823",
                                 "locator" : "433:10-433:28",
                                 "name" : "ToValue",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "path" : "abatement",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "822",
                                       "locator" : "433:10-433:18",
                                       "name" : "condition",
                                       "type" : "OperandRef"
                                    }
                                 } ]
                              },
                              "isTypeSpecifier" : {
                                 "localId" : "824",
                                 "locator" : "433:33-433:47",
                                 "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                 "type" : "NamedTypeSpecifier"
                              }
                           },
                           "then" : {
                              "type" : "Interval",
                              "low" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "842",
                                          "locator" : "434:3-435:73",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "832",
                                             "locator" : "434:12-434:71",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "827",
                                                "locator" : "434:12-434:28",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "826",
                                                      "locator" : "434:12-434:18",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "831",
                                                "locator" : "434:32-434:71",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "829",
                                                   "locator" : "434:33-434:51",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "828",
                                                         "locator" : "434:33-434:41",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "830",
                                                   "locator" : "434:56-434:70",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "841",
                                             "locator" : "435:4-435:72",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "839",
                                                "locator" : "435:4-435:63",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "834",
                                                   "locator" : "435:4-435:20",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "833",
                                                         "locator" : "435:4-435:10",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "838",
                                                   "locator" : "435:24-435:63",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "836",
                                                      "locator" : "435:25-435:43",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "835",
                                                            "locator" : "435:25-435:33",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "837",
                                                      "locator" : "435:48-435:62",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "840",
                                                "locator" : "435:67-435:72",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "lowClosedExpression" : {
                                 "path" : "lowClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "842",
                                    "locator" : "434:3-435:73",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "832",
                                       "locator" : "434:12-434:71",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "827",
                                          "locator" : "434:12-434:28",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "826",
                                                "locator" : "434:12-434:18",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "831",
                                          "locator" : "434:32-434:71",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "829",
                                             "locator" : "434:33-434:51",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "828",
                                                   "locator" : "434:33-434:41",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "830",
                                             "locator" : "434:56-434:70",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "841",
                                       "locator" : "435:4-435:72",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "839",
                                          "locator" : "435:4-435:63",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "834",
                                             "locator" : "435:4-435:20",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "833",
                                                   "locator" : "435:4-435:10",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "838",
                                             "locator" : "435:24-435:63",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "836",
                                                "locator" : "435:25-435:43",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "835",
                                                      "locator" : "435:25-435:33",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "837",
                                                "locator" : "435:48-435:62",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "840",
                                          "locator" : "435:67-435:72",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              },
                              "high" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "842",
                                          "locator" : "434:3-435:73",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "832",
                                             "locator" : "434:12-434:71",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "827",
                                                "locator" : "434:12-434:28",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "826",
                                                      "locator" : "434:12-434:18",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "831",
                                                "locator" : "434:32-434:71",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "829",
                                                   "locator" : "434:33-434:51",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "828",
                                                         "locator" : "434:33-434:41",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "830",
                                                   "locator" : "434:56-434:70",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "841",
                                             "locator" : "435:4-435:72",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "839",
                                                "locator" : "435:4-435:63",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "834",
                                                   "locator" : "435:4-435:20",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "833",
                                                         "locator" : "435:4-435:10",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "838",
                                                   "locator" : "435:24-435:63",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "836",
                                                      "locator" : "435:25-435:43",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "835",
                                                            "locator" : "435:25-435:33",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "837",
                                                      "locator" : "435:48-435:62",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "840",
                                                "locator" : "435:67-435:72",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "highClosedExpression" : {
                                 "path" : "highClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "842",
                                    "locator" : "434:3-435:73",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "832",
                                       "locator" : "434:12-434:71",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "827",
                                          "locator" : "434:12-434:28",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "826",
                                                "locator" : "434:12-434:18",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "831",
                                          "locator" : "434:32-434:71",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "829",
                                             "locator" : "434:33-434:51",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "828",
                                                   "locator" : "434:33-434:41",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "830",
                                             "locator" : "434:56-434:70",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "841",
                                       "locator" : "435:4-435:72",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "839",
                                          "locator" : "435:4-435:63",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "834",
                                             "locator" : "435:4-435:20",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "833",
                                                   "locator" : "435:4-435:10",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "838",
                                             "locator" : "435:24-435:63",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "836",
                                                "locator" : "435:25-435:43",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "835",
                                                      "locator" : "435:25-435:33",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "837",
                                                "locator" : "435:48-435:62",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "840",
                                          "locator" : "435:67-435:72",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              }
                           },
                           "else" : {
                              "localId" : "884",
                              "locator" : "436:7-441:32",
                              "type" : "If",
                              "condition" : {
                                 "localId" : "847",
                                 "locator" : "436:10-436:57",
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "844",
                                    "locator" : "436:10-436:28",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "abatement",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "843",
                                          "locator" : "436:10-436:18",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "846",
                                    "locator" : "436:33-436:57",
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "localId" : "845",
                                       "locator" : "436:42-436:56",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "type" : "Interval",
                                 "low" : {
                                    "type" : "ToDateTime",
                                    "operand" : {
                                       "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "low",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "866",
                                             "locator" : "437:4-438:79",
                                             "lowClosed" : true,
                                             "highClosed" : false,
                                             "type" : "Interval",
                                             "low" : {
                                                "localId" : "855",
                                                "locator" : "437:13-437:76",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "849",
                                                   "locator" : "437:13-437:29",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "848",
                                                         "locator" : "437:13-437:19",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "854",
                                                   "locator" : "437:33-437:76",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "852",
                                                      "locator" : "437:34-437:56",
                                                      "path" : "low",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "851",
                                                         "locator" : "437:34-437:52",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "850",
                                                               "locator" : "437:34-437:42",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "853",
                                                      "locator" : "437:61-437:75",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             },
                                             "high" : {
                                                "localId" : "865",
                                                "locator" : "438:5-438:78",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "863",
                                                   "locator" : "438:5-438:69",
                                                   "type" : "Add",
                                                   "operand" : [ {
                                                      "localId" : "857",
                                                      "locator" : "438:5-438:21",
                                                      "path" : "value",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "birthDate",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "856",
                                                            "locator" : "438:5-438:11",
                                                            "name" : "Patient",
                                                            "type" : "ExpressionRef"
                                                         }
                                                      }
                                                   }, {
                                                      "localId" : "862",
                                                      "locator" : "438:25-438:69",
                                                      "strict" : false,
                                                      "type" : "As",
                                                      "operand" : {
                                                         "localId" : "860",
                                                         "locator" : "438:26-438:49",
                                                         "path" : "high",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "859",
                                                            "locator" : "438:26-438:44",
                                                            "name" : "ToValue",
                                                            "libraryName" : "FHIRHelpers",
                                                            "type" : "FunctionRef",
                                                            "operand" : [ {
                                                               "path" : "abatement",
                                                               "type" : "Property",
                                                               "source" : {
                                                                  "localId" : "858",
                                                                  "locator" : "438:26-438:34",
                                                                  "name" : "condition",
                                                                  "type" : "OperandRef"
                                                               }
                                                            } ]
                                                         }
                                                      },
                                                      "asTypeSpecifier" : {
                                                         "localId" : "861",
                                                         "locator" : "438:54-438:68",
                                                         "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                         "type" : "NamedTypeSpecifier"
                                                      }
                                                   } ]
                                                }, {
                                                   "localId" : "864",
                                                   "locator" : "438:73-438:78",
                                                   "value" : 1,
                                                   "unit" : "year",
                                                   "type" : "Quantity"
                                                } ]
                                             }
                                          }
                                       }
                                    }
                                 },
                                 "lowClosedExpression" : {
                                    "path" : "lowClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "866",
                                       "locator" : "437:4-438:79",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "855",
                                          "locator" : "437:13-437:76",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "849",
                                             "locator" : "437:13-437:29",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "848",
                                                   "locator" : "437:13-437:19",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "854",
                                             "locator" : "437:33-437:76",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "852",
                                                "locator" : "437:34-437:56",
                                                "path" : "low",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "851",
                                                   "locator" : "437:34-437:52",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "850",
                                                         "locator" : "437:34-437:42",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "853",
                                                "locator" : "437:61-437:75",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "865",
                                          "locator" : "438:5-438:78",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "863",
                                             "locator" : "438:5-438:69",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "857",
                                                "locator" : "438:5-438:21",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "856",
                                                      "locator" : "438:5-438:11",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "862",
                                                "locator" : "438:25-438:69",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "860",
                                                   "locator" : "438:26-438:49",
                                                   "path" : "high",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "859",
                                                      "locator" : "438:26-438:44",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "858",
                                                            "locator" : "438:26-438:34",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "861",
                                                   "locator" : "438:54-438:68",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "864",
                                             "locator" : "438:73-438:78",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 },
                                 "high" : {
                                    "type" : "ToDateTime",
                                    "operand" : {
                                       "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "866",
                                             "locator" : "437:4-438:79",
                                             "lowClosed" : true,
                                             "highClosed" : false,
                                             "type" : "Interval",
                                             "low" : {
                                                "localId" : "855",
                                                "locator" : "437:13-437:76",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "849",
                                                   "locator" : "437:13-437:29",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "848",
                                                         "locator" : "437:13-437:19",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "854",
                                                   "locator" : "437:33-437:76",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "852",
                                                      "locator" : "437:34-437:56",
                                                      "path" : "low",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "851",
                                                         "locator" : "437:34-437:52",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "850",
                                                               "locator" : "437:34-437:42",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "853",
                                                      "locator" : "437:61-437:75",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             },
                                             "high" : {
                                                "localId" : "865",
                                                "locator" : "438:5-438:78",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "863",
                                                   "locator" : "438:5-438:69",
                                                   "type" : "Add",
                                                   "operand" : [ {
                                                      "localId" : "857",
                                                      "locator" : "438:5-438:21",
                                                      "path" : "value",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "birthDate",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "856",
                                                            "locator" : "438:5-438:11",
                                                            "name" : "Patient",
                                                            "type" : "ExpressionRef"
                                                         }
                                                      }
                                                   }, {
                                                      "localId" : "862",
                                                      "locator" : "438:25-438:69",
                                                      "strict" : false,
                                                      "type" : "As",
                                                      "operand" : {
                                                         "localId" : "860",
                                                         "locator" : "438:26-438:49",
                                                         "path" : "high",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "859",
                                                            "locator" : "438:26-438:44",
                                                            "name" : "ToValue",
                                                            "libraryName" : "FHIRHelpers",
                                                            "type" : "FunctionRef",
                                                            "operand" : [ {
                                                               "path" : "abatement",
                                                               "type" : "Property",
                                                               "source" : {
                                                                  "localId" : "858",
                                                                  "locator" : "438:26-438:34",
                                                                  "name" : "condition",
                                                                  "type" : "OperandRef"
                                                               }
                                                            } ]
                                                         }
                                                      },
                                                      "asTypeSpecifier" : {
                                                         "localId" : "861",
                                                         "locator" : "438:54-438:68",
                                                         "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                         "type" : "NamedTypeSpecifier"
                                                      }
                                                   } ]
                                                }, {
                                                   "localId" : "864",
                                                   "locator" : "438:73-438:78",
                                                   "value" : 1,
                                                   "unit" : "year",
                                                   "type" : "Quantity"
                                                } ]
                                             }
                                          }
                                       }
                                    }
                                 },
                                 "highClosedExpression" : {
                                    "path" : "highClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "866",
                                       "locator" : "437:4-438:79",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "855",
                                          "locator" : "437:13-437:76",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "849",
                                             "locator" : "437:13-437:29",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "848",
                                                   "locator" : "437:13-437:19",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "854",
                                             "locator" : "437:33-437:76",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "852",
                                                "locator" : "437:34-437:56",
                                                "path" : "low",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "851",
                                                   "locator" : "437:34-437:52",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "850",
                                                         "locator" : "437:34-437:42",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "853",
                                                "locator" : "437:61-437:75",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "865",
                                          "locator" : "438:5-438:78",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "863",
                                             "locator" : "438:5-438:69",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "857",
                                                "locator" : "438:5-438:21",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "856",
                                                      "locator" : "438:5-438:11",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "862",
                                                "locator" : "438:25-438:69",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "860",
                                                   "locator" : "438:26-438:49",
                                                   "path" : "high",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "859",
                                                      "locator" : "438:26-438:44",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "858",
                                                            "locator" : "438:26-438:34",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "861",
                                                   "locator" : "438:54-438:68",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "864",
                                             "locator" : "438:73-438:78",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              },
                              "else" : {
                                 "localId" : "883",
                                 "locator" : "439:7-441:32",
                                 "type" : "If",
                                 "condition" : {
                                    "localId" : "871",
                                    "locator" : "439:10-439:50",
                                    "type" : "Is",
                                    "operand" : {
                                       "localId" : "868",
                                       "locator" : "439:10-439:28",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "abatement",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "867",
                                             "locator" : "439:10-439:18",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    },
                                    "isTypeSpecifier" : {
                                       "localId" : "870",
                                       "locator" : "439:33-439:50",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "869",
                                          "locator" : "439:42-439:49",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "then" : {
                                    "localId" : "878",
                                    "locator" : "440:4-440:62",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "874",
                                       "locator" : "440:13-440:35",
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "873",
                                          "locator" : "440:13-440:31",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "872",
                                                "locator" : "440:13-440:21",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       }
                                    },
                                    "high" : {
                                       "localId" : "877",
                                       "locator" : "440:38-440:61",
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "876",
                                          "locator" : "440:38-440:56",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "875",
                                                "locator" : "440:38-440:46",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       }
                                    }
                                 },
                                 "else" : {
                                    "type" : "Interval",
                                    "low" : {
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "low",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "882",
                                             "locator" : "441:7-441:32",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "879",
                                                "locator" : "441:7-441:10",
                                                "type" : "Null"
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "881",
                                                "locator" : "441:15-441:32",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "880",
                                                   "locator" : "441:24-441:31",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "type" : "ChoiceTypeSpecifier",
                                          "choice" : [ {
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }, {
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          } ]
                                       }
                                    },
                                    "lowClosedExpression" : {
                                       "path" : "lowClosed",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    },
                                    "high" : {
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "882",
                                             "locator" : "441:7-441:32",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "879",
                                                "locator" : "441:7-441:10",
                                                "type" : "Null"
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "881",
                                                "locator" : "441:15-441:32",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "880",
                                                   "locator" : "441:24-441:31",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "type" : "ChoiceTypeSpecifier",
                                          "choice" : [ {
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }, {
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          } ]
                                       }
                                    },
                                    "highClosedExpression" : {
                                       "path" : "highClosed",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    }
                                 }
                              }
                           }
                        }
                     }
                  },
                  "lowClosedExpression" : {
                     "path" : "lowClosed",
                     "type" : "Property",
                     "source" : {
                        "localId" : "885",
                        "locator" : "433:7-441:32",
                        "type" : "If",
                        "condition" : {
                           "localId" : "825",
                           "locator" : "433:10-433:47",
                           "type" : "Is",
                           "operand" : {
                              "localId" : "823",
                              "locator" : "433:10-433:28",
                              "name" : "ToValue",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "path" : "abatement",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "822",
                                    "locator" : "433:10-433:18",
                                    "name" : "condition",
                                    "type" : "OperandRef"
                                 }
                              } ]
                           },
                           "isTypeSpecifier" : {
                              "localId" : "824",
                              "locator" : "433:33-433:47",
                              "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                              "type" : "NamedTypeSpecifier"
                           }
                        },
                        "then" : {
                           "type" : "Interval",
                           "low" : {
                              "type" : "ToDateTime",
                              "operand" : {
                                 "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                 "type" : "As",
                                 "operand" : {
                                    "path" : "low",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "842",
                                       "locator" : "434:3-435:73",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "832",
                                          "locator" : "434:12-434:71",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "827",
                                             "locator" : "434:12-434:28",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "826",
                                                   "locator" : "434:12-434:18",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "831",
                                             "locator" : "434:32-434:71",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "829",
                                                "locator" : "434:33-434:51",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "828",
                                                      "locator" : "434:33-434:41",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "830",
                                                "locator" : "434:56-434:70",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "841",
                                          "locator" : "435:4-435:72",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "839",
                                             "locator" : "435:4-435:63",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "834",
                                                "locator" : "435:4-435:20",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "833",
                                                      "locator" : "435:4-435:10",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "838",
                                                "locator" : "435:24-435:63",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "836",
                                                   "locator" : "435:25-435:43",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "835",
                                                         "locator" : "435:25-435:33",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "837",
                                                   "locator" : "435:48-435:62",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "840",
                                             "locator" : "435:67-435:72",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              }
                           },
                           "lowClosedExpression" : {
                              "path" : "lowClosed",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "842",
                                 "locator" : "434:3-435:73",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "832",
                                    "locator" : "434:12-434:71",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "827",
                                       "locator" : "434:12-434:28",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "826",
                                             "locator" : "434:12-434:18",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "localId" : "831",
                                       "locator" : "434:32-434:71",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "829",
                                          "locator" : "434:33-434:51",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "828",
                                                "locator" : "434:33-434:41",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "830",
                                          "locator" : "434:56-434:70",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "841",
                                    "locator" : "435:4-435:72",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "839",
                                       "locator" : "435:4-435:63",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "834",
                                          "locator" : "435:4-435:20",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "833",
                                                "locator" : "435:4-435:10",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "838",
                                          "locator" : "435:24-435:63",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "836",
                                             "locator" : "435:25-435:43",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "835",
                                                   "locator" : "435:25-435:33",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "837",
                                             "locator" : "435:48-435:62",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "840",
                                       "locator" : "435:67-435:72",
                                       "value" : 1,
                                       "unit" : "year",
                                       "type" : "Quantity"
                                    } ]
                                 }
                              }
                           },
                           "high" : {
                              "type" : "ToDateTime",
                              "operand" : {
                                 "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                 "type" : "As",
                                 "operand" : {
                                    "path" : "high",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "842",
                                       "locator" : "434:3-435:73",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "832",
                                          "locator" : "434:12-434:71",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "827",
                                             "locator" : "434:12-434:28",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "826",
                                                   "locator" : "434:12-434:18",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "831",
                                             "locator" : "434:32-434:71",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "829",
                                                "locator" : "434:33-434:51",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "828",
                                                      "locator" : "434:33-434:41",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "830",
                                                "locator" : "434:56-434:70",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "841",
                                          "locator" : "435:4-435:72",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "839",
                                             "locator" : "435:4-435:63",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "834",
                                                "locator" : "435:4-435:20",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "833",
                                                      "locator" : "435:4-435:10",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "838",
                                                "locator" : "435:24-435:63",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "836",
                                                   "locator" : "435:25-435:43",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "835",
                                                         "locator" : "435:25-435:33",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "837",
                                                   "locator" : "435:48-435:62",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "840",
                                             "locator" : "435:67-435:72",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              }
                           },
                           "highClosedExpression" : {
                              "path" : "highClosed",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "842",
                                 "locator" : "434:3-435:73",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "832",
                                    "locator" : "434:12-434:71",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "827",
                                       "locator" : "434:12-434:28",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "826",
                                             "locator" : "434:12-434:18",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "localId" : "831",
                                       "locator" : "434:32-434:71",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "829",
                                          "locator" : "434:33-434:51",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "828",
                                                "locator" : "434:33-434:41",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "830",
                                          "locator" : "434:56-434:70",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "841",
                                    "locator" : "435:4-435:72",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "839",
                                       "locator" : "435:4-435:63",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "834",
                                          "locator" : "435:4-435:20",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "833",
                                                "locator" : "435:4-435:10",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "838",
                                          "locator" : "435:24-435:63",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "836",
                                             "locator" : "435:25-435:43",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "835",
                                                   "locator" : "435:25-435:33",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "837",
                                             "locator" : "435:48-435:62",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "840",
                                       "locator" : "435:67-435:72",
                                       "value" : 1,
                                       "unit" : "year",
                                       "type" : "Quantity"
                                    } ]
                                 }
                              }
                           }
                        },
                        "else" : {
                           "localId" : "884",
                           "locator" : "436:7-441:32",
                           "type" : "If",
                           "condition" : {
                              "localId" : "847",
                              "locator" : "436:10-436:57",
                              "type" : "Is",
                              "operand" : {
                                 "localId" : "844",
                                 "locator" : "436:10-436:28",
                                 "name" : "ToValue",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "path" : "abatement",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "843",
                                       "locator" : "436:10-436:18",
                                       "name" : "condition",
                                       "type" : "OperandRef"
                                    }
                                 } ]
                              },
                              "isTypeSpecifier" : {
                                 "localId" : "846",
                                 "locator" : "436:33-436:57",
                                 "type" : "IntervalTypeSpecifier",
                                 "pointType" : {
                                    "localId" : "845",
                                    "locator" : "436:42-436:56",
                                    "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                    "type" : "NamedTypeSpecifier"
                                 }
                              }
                           },
                           "then" : {
                              "type" : "Interval",
                              "low" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "866",
                                          "locator" : "437:4-438:79",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "855",
                                             "locator" : "437:13-437:76",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "849",
                                                "locator" : "437:13-437:29",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "848",
                                                      "locator" : "437:13-437:19",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "854",
                                                "locator" : "437:33-437:76",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "852",
                                                   "locator" : "437:34-437:56",
                                                   "path" : "low",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "851",
                                                      "locator" : "437:34-437:52",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "850",
                                                            "locator" : "437:34-437:42",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "853",
                                                   "locator" : "437:61-437:75",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "865",
                                             "locator" : "438:5-438:78",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "863",
                                                "locator" : "438:5-438:69",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "857",
                                                   "locator" : "438:5-438:21",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "856",
                                                         "locator" : "438:5-438:11",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "862",
                                                   "locator" : "438:25-438:69",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "860",
                                                      "locator" : "438:26-438:49",
                                                      "path" : "high",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "859",
                                                         "locator" : "438:26-438:44",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "858",
                                                               "locator" : "438:26-438:34",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "861",
                                                      "locator" : "438:54-438:68",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "864",
                                                "locator" : "438:73-438:78",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "lowClosedExpression" : {
                                 "path" : "lowClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "866",
                                    "locator" : "437:4-438:79",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "855",
                                       "locator" : "437:13-437:76",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "849",
                                          "locator" : "437:13-437:29",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "848",
                                                "locator" : "437:13-437:19",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "854",
                                          "locator" : "437:33-437:76",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "852",
                                             "locator" : "437:34-437:56",
                                             "path" : "low",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "851",
                                                "locator" : "437:34-437:52",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "850",
                                                      "locator" : "437:34-437:42",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "853",
                                             "locator" : "437:61-437:75",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "865",
                                       "locator" : "438:5-438:78",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "863",
                                          "locator" : "438:5-438:69",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "857",
                                             "locator" : "438:5-438:21",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "856",
                                                   "locator" : "438:5-438:11",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "862",
                                             "locator" : "438:25-438:69",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "860",
                                                "locator" : "438:26-438:49",
                                                "path" : "high",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "859",
                                                   "locator" : "438:26-438:44",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "858",
                                                         "locator" : "438:26-438:34",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "861",
                                                "locator" : "438:54-438:68",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "864",
                                          "locator" : "438:73-438:78",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              },
                              "high" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "866",
                                          "locator" : "437:4-438:79",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "855",
                                             "locator" : "437:13-437:76",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "849",
                                                "locator" : "437:13-437:29",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "848",
                                                      "locator" : "437:13-437:19",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "854",
                                                "locator" : "437:33-437:76",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "852",
                                                   "locator" : "437:34-437:56",
                                                   "path" : "low",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "851",
                                                      "locator" : "437:34-437:52",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "850",
                                                            "locator" : "437:34-437:42",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "853",
                                                   "locator" : "437:61-437:75",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "865",
                                             "locator" : "438:5-438:78",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "863",
                                                "locator" : "438:5-438:69",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "857",
                                                   "locator" : "438:5-438:21",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "856",
                                                         "locator" : "438:5-438:11",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "862",
                                                   "locator" : "438:25-438:69",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "860",
                                                      "locator" : "438:26-438:49",
                                                      "path" : "high",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "859",
                                                         "locator" : "438:26-438:44",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "858",
                                                               "locator" : "438:26-438:34",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "861",
                                                      "locator" : "438:54-438:68",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "864",
                                                "locator" : "438:73-438:78",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "highClosedExpression" : {
                                 "path" : "highClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "866",
                                    "locator" : "437:4-438:79",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "855",
                                       "locator" : "437:13-437:76",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "849",
                                          "locator" : "437:13-437:29",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "848",
                                                "locator" : "437:13-437:19",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "854",
                                          "locator" : "437:33-437:76",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "852",
                                             "locator" : "437:34-437:56",
                                             "path" : "low",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "851",
                                                "locator" : "437:34-437:52",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "850",
                                                      "locator" : "437:34-437:42",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "853",
                                             "locator" : "437:61-437:75",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "865",
                                       "locator" : "438:5-438:78",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "863",
                                          "locator" : "438:5-438:69",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "857",
                                             "locator" : "438:5-438:21",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "856",
                                                   "locator" : "438:5-438:11",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "862",
                                             "locator" : "438:25-438:69",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "860",
                                                "locator" : "438:26-438:49",
                                                "path" : "high",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "859",
                                                   "locator" : "438:26-438:44",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "858",
                                                         "locator" : "438:26-438:34",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "861",
                                                "locator" : "438:54-438:68",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "864",
                                          "locator" : "438:73-438:78",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              }
                           },
                           "else" : {
                              "localId" : "883",
                              "locator" : "439:7-441:32",
                              "type" : "If",
                              "condition" : {
                                 "localId" : "871",
                                 "locator" : "439:10-439:50",
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "868",
                                    "locator" : "439:10-439:28",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "abatement",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "867",
                                          "locator" : "439:10-439:18",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "870",
                                    "locator" : "439:33-439:50",
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "localId" : "869",
                                       "locator" : "439:42-439:49",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "localId" : "878",
                                 "locator" : "440:4-440:62",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "874",
                                    "locator" : "440:13-440:35",
                                    "path" : "low",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "873",
                                       "locator" : "440:13-440:31",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "abatement",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "872",
                                             "locator" : "440:13-440:21",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 },
                                 "high" : {
                                    "localId" : "877",
                                    "locator" : "440:38-440:61",
                                    "path" : "high",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "876",
                                       "locator" : "440:38-440:56",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "abatement",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "875",
                                             "locator" : "440:38-440:46",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 }
                              },
                              "else" : {
                                 "type" : "Interval",
                                 "low" : {
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "type" : "ChoiceTypeSpecifier",
                                       "choice" : [ {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       } ]
                                    }
                                 },
                                 "lowClosedExpression" : {
                                    "path" : "lowClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "882",
                                       "locator" : "441:7-441:32",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "879",
                                          "locator" : "441:7-441:10",
                                          "type" : "Null"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "881",
                                          "locator" : "441:15-441:32",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "880",
                                             "locator" : "441:24-441:31",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    }
                                 },
                                 "high" : {
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "type" : "ChoiceTypeSpecifier",
                                       "choice" : [ {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       } ]
                                    }
                                 },
                                 "highClosedExpression" : {
                                    "path" : "highClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "882",
                                       "locator" : "441:7-441:32",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "879",
                                          "locator" : "441:7-441:10",
                                          "type" : "Null"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "881",
                                          "locator" : "441:15-441:32",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "880",
                                             "locator" : "441:24-441:31",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    }
                                 }
                              }
                           }
                        }
                     }
                  },
                  "high" : {
                     "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "As",
                     "operand" : {
                        "path" : "high",
                        "type" : "Property",
                        "source" : {
                           "localId" : "885",
                           "locator" : "433:7-441:32",
                           "type" : "If",
                           "condition" : {
                              "localId" : "825",
                              "locator" : "433:10-433:47",
                              "type" : "Is",
                              "operand" : {
                                 "localId" : "823",
                                 "locator" : "433:10-433:28",
                                 "name" : "ToValue",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "path" : "abatement",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "822",
                                       "locator" : "433:10-433:18",
                                       "name" : "condition",
                                       "type" : "OperandRef"
                                    }
                                 } ]
                              },
                              "isTypeSpecifier" : {
                                 "localId" : "824",
                                 "locator" : "433:33-433:47",
                                 "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                 "type" : "NamedTypeSpecifier"
                              }
                           },
                           "then" : {
                              "type" : "Interval",
                              "low" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "842",
                                          "locator" : "434:3-435:73",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "832",
                                             "locator" : "434:12-434:71",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "827",
                                                "locator" : "434:12-434:28",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "826",
                                                      "locator" : "434:12-434:18",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "831",
                                                "locator" : "434:32-434:71",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "829",
                                                   "locator" : "434:33-434:51",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "828",
                                                         "locator" : "434:33-434:41",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "830",
                                                   "locator" : "434:56-434:70",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "841",
                                             "locator" : "435:4-435:72",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "839",
                                                "locator" : "435:4-435:63",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "834",
                                                   "locator" : "435:4-435:20",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "833",
                                                         "locator" : "435:4-435:10",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "838",
                                                   "locator" : "435:24-435:63",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "836",
                                                      "locator" : "435:25-435:43",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "835",
                                                            "locator" : "435:25-435:33",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "837",
                                                      "locator" : "435:48-435:62",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "840",
                                                "locator" : "435:67-435:72",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "lowClosedExpression" : {
                                 "path" : "lowClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "842",
                                    "locator" : "434:3-435:73",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "832",
                                       "locator" : "434:12-434:71",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "827",
                                          "locator" : "434:12-434:28",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "826",
                                                "locator" : "434:12-434:18",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "831",
                                          "locator" : "434:32-434:71",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "829",
                                             "locator" : "434:33-434:51",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "828",
                                                   "locator" : "434:33-434:41",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "830",
                                             "locator" : "434:56-434:70",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "841",
                                       "locator" : "435:4-435:72",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "839",
                                          "locator" : "435:4-435:63",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "834",
                                             "locator" : "435:4-435:20",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "833",
                                                   "locator" : "435:4-435:10",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "838",
                                             "locator" : "435:24-435:63",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "836",
                                                "locator" : "435:25-435:43",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "835",
                                                      "locator" : "435:25-435:33",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "837",
                                                "locator" : "435:48-435:62",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "840",
                                          "locator" : "435:67-435:72",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              },
                              "high" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "842",
                                          "locator" : "434:3-435:73",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "832",
                                             "locator" : "434:12-434:71",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "827",
                                                "locator" : "434:12-434:28",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "826",
                                                      "locator" : "434:12-434:18",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "831",
                                                "locator" : "434:32-434:71",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "829",
                                                   "locator" : "434:33-434:51",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "828",
                                                         "locator" : "434:33-434:41",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "830",
                                                   "locator" : "434:56-434:70",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "841",
                                             "locator" : "435:4-435:72",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "839",
                                                "locator" : "435:4-435:63",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "834",
                                                   "locator" : "435:4-435:20",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "833",
                                                         "locator" : "435:4-435:10",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "838",
                                                   "locator" : "435:24-435:63",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "836",
                                                      "locator" : "435:25-435:43",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "835",
                                                            "locator" : "435:25-435:33",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "837",
                                                      "locator" : "435:48-435:62",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "840",
                                                "locator" : "435:67-435:72",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "highClosedExpression" : {
                                 "path" : "highClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "842",
                                    "locator" : "434:3-435:73",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "832",
                                       "locator" : "434:12-434:71",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "827",
                                          "locator" : "434:12-434:28",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "826",
                                                "locator" : "434:12-434:18",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "831",
                                          "locator" : "434:32-434:71",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "829",
                                             "locator" : "434:33-434:51",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "828",
                                                   "locator" : "434:33-434:41",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "830",
                                             "locator" : "434:56-434:70",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "841",
                                       "locator" : "435:4-435:72",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "839",
                                          "locator" : "435:4-435:63",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "834",
                                             "locator" : "435:4-435:20",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "833",
                                                   "locator" : "435:4-435:10",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "838",
                                             "locator" : "435:24-435:63",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "836",
                                                "locator" : "435:25-435:43",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "835",
                                                      "locator" : "435:25-435:33",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "837",
                                                "locator" : "435:48-435:62",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "840",
                                          "locator" : "435:67-435:72",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              }
                           },
                           "else" : {
                              "localId" : "884",
                              "locator" : "436:7-441:32",
                              "type" : "If",
                              "condition" : {
                                 "localId" : "847",
                                 "locator" : "436:10-436:57",
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "844",
                                    "locator" : "436:10-436:28",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "abatement",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "843",
                                          "locator" : "436:10-436:18",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "846",
                                    "locator" : "436:33-436:57",
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "localId" : "845",
                                       "locator" : "436:42-436:56",
                                       "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "type" : "Interval",
                                 "low" : {
                                    "type" : "ToDateTime",
                                    "operand" : {
                                       "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "low",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "866",
                                             "locator" : "437:4-438:79",
                                             "lowClosed" : true,
                                             "highClosed" : false,
                                             "type" : "Interval",
                                             "low" : {
                                                "localId" : "855",
                                                "locator" : "437:13-437:76",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "849",
                                                   "locator" : "437:13-437:29",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "848",
                                                         "locator" : "437:13-437:19",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "854",
                                                   "locator" : "437:33-437:76",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "852",
                                                      "locator" : "437:34-437:56",
                                                      "path" : "low",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "851",
                                                         "locator" : "437:34-437:52",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "850",
                                                               "locator" : "437:34-437:42",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "853",
                                                      "locator" : "437:61-437:75",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             },
                                             "high" : {
                                                "localId" : "865",
                                                "locator" : "438:5-438:78",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "863",
                                                   "locator" : "438:5-438:69",
                                                   "type" : "Add",
                                                   "operand" : [ {
                                                      "localId" : "857",
                                                      "locator" : "438:5-438:21",
                                                      "path" : "value",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "birthDate",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "856",
                                                            "locator" : "438:5-438:11",
                                                            "name" : "Patient",
                                                            "type" : "ExpressionRef"
                                                         }
                                                      }
                                                   }, {
                                                      "localId" : "862",
                                                      "locator" : "438:25-438:69",
                                                      "strict" : false,
                                                      "type" : "As",
                                                      "operand" : {
                                                         "localId" : "860",
                                                         "locator" : "438:26-438:49",
                                                         "path" : "high",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "859",
                                                            "locator" : "438:26-438:44",
                                                            "name" : "ToValue",
                                                            "libraryName" : "FHIRHelpers",
                                                            "type" : "FunctionRef",
                                                            "operand" : [ {
                                                               "path" : "abatement",
                                                               "type" : "Property",
                                                               "source" : {
                                                                  "localId" : "858",
                                                                  "locator" : "438:26-438:34",
                                                                  "name" : "condition",
                                                                  "type" : "OperandRef"
                                                               }
                                                            } ]
                                                         }
                                                      },
                                                      "asTypeSpecifier" : {
                                                         "localId" : "861",
                                                         "locator" : "438:54-438:68",
                                                         "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                         "type" : "NamedTypeSpecifier"
                                                      }
                                                   } ]
                                                }, {
                                                   "localId" : "864",
                                                   "locator" : "438:73-438:78",
                                                   "value" : 1,
                                                   "unit" : "year",
                                                   "type" : "Quantity"
                                                } ]
                                             }
                                          }
                                       }
                                    }
                                 },
                                 "lowClosedExpression" : {
                                    "path" : "lowClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "866",
                                       "locator" : "437:4-438:79",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "855",
                                          "locator" : "437:13-437:76",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "849",
                                             "locator" : "437:13-437:29",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "848",
                                                   "locator" : "437:13-437:19",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "854",
                                             "locator" : "437:33-437:76",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "852",
                                                "locator" : "437:34-437:56",
                                                "path" : "low",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "851",
                                                   "locator" : "437:34-437:52",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "850",
                                                         "locator" : "437:34-437:42",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "853",
                                                "locator" : "437:61-437:75",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "865",
                                          "locator" : "438:5-438:78",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "863",
                                             "locator" : "438:5-438:69",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "857",
                                                "locator" : "438:5-438:21",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "856",
                                                      "locator" : "438:5-438:11",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "862",
                                                "locator" : "438:25-438:69",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "860",
                                                   "locator" : "438:26-438:49",
                                                   "path" : "high",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "859",
                                                      "locator" : "438:26-438:44",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "858",
                                                            "locator" : "438:26-438:34",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "861",
                                                   "locator" : "438:54-438:68",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "864",
                                             "locator" : "438:73-438:78",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 },
                                 "high" : {
                                    "type" : "ToDateTime",
                                    "operand" : {
                                       "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "866",
                                             "locator" : "437:4-438:79",
                                             "lowClosed" : true,
                                             "highClosed" : false,
                                             "type" : "Interval",
                                             "low" : {
                                                "localId" : "855",
                                                "locator" : "437:13-437:76",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "849",
                                                   "locator" : "437:13-437:29",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "848",
                                                         "locator" : "437:13-437:19",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "854",
                                                   "locator" : "437:33-437:76",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "852",
                                                      "locator" : "437:34-437:56",
                                                      "path" : "low",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "851",
                                                         "locator" : "437:34-437:52",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "850",
                                                               "locator" : "437:34-437:42",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "853",
                                                      "locator" : "437:61-437:75",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             },
                                             "high" : {
                                                "localId" : "865",
                                                "locator" : "438:5-438:78",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "863",
                                                   "locator" : "438:5-438:69",
                                                   "type" : "Add",
                                                   "operand" : [ {
                                                      "localId" : "857",
                                                      "locator" : "438:5-438:21",
                                                      "path" : "value",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "birthDate",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "856",
                                                            "locator" : "438:5-438:11",
                                                            "name" : "Patient",
                                                            "type" : "ExpressionRef"
                                                         }
                                                      }
                                                   }, {
                                                      "localId" : "862",
                                                      "locator" : "438:25-438:69",
                                                      "strict" : false,
                                                      "type" : "As",
                                                      "operand" : {
                                                         "localId" : "860",
                                                         "locator" : "438:26-438:49",
                                                         "path" : "high",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "859",
                                                            "locator" : "438:26-438:44",
                                                            "name" : "ToValue",
                                                            "libraryName" : "FHIRHelpers",
                                                            "type" : "FunctionRef",
                                                            "operand" : [ {
                                                               "path" : "abatement",
                                                               "type" : "Property",
                                                               "source" : {
                                                                  "localId" : "858",
                                                                  "locator" : "438:26-438:34",
                                                                  "name" : "condition",
                                                                  "type" : "OperandRef"
                                                               }
                                                            } ]
                                                         }
                                                      },
                                                      "asTypeSpecifier" : {
                                                         "localId" : "861",
                                                         "locator" : "438:54-438:68",
                                                         "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                         "type" : "NamedTypeSpecifier"
                                                      }
                                                   } ]
                                                }, {
                                                   "localId" : "864",
                                                   "locator" : "438:73-438:78",
                                                   "value" : 1,
                                                   "unit" : "year",
                                                   "type" : "Quantity"
                                                } ]
                                             }
                                          }
                                       }
                                    }
                                 },
                                 "highClosedExpression" : {
                                    "path" : "highClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "866",
                                       "locator" : "437:4-438:79",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "855",
                                          "locator" : "437:13-437:76",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "849",
                                             "locator" : "437:13-437:29",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "848",
                                                   "locator" : "437:13-437:19",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "854",
                                             "locator" : "437:33-437:76",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "852",
                                                "locator" : "437:34-437:56",
                                                "path" : "low",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "851",
                                                   "locator" : "437:34-437:52",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "850",
                                                         "locator" : "437:34-437:42",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "853",
                                                "locator" : "437:61-437:75",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "865",
                                          "locator" : "438:5-438:78",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "863",
                                             "locator" : "438:5-438:69",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "857",
                                                "locator" : "438:5-438:21",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "856",
                                                      "locator" : "438:5-438:11",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "862",
                                                "locator" : "438:25-438:69",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "860",
                                                   "locator" : "438:26-438:49",
                                                   "path" : "high",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "859",
                                                      "locator" : "438:26-438:44",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "858",
                                                            "locator" : "438:26-438:34",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "861",
                                                   "locator" : "438:54-438:68",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "864",
                                             "locator" : "438:73-438:78",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              },
                              "else" : {
                                 "localId" : "883",
                                 "locator" : "439:7-441:32",
                                 "type" : "If",
                                 "condition" : {
                                    "localId" : "871",
                                    "locator" : "439:10-439:50",
                                    "type" : "Is",
                                    "operand" : {
                                       "localId" : "868",
                                       "locator" : "439:10-439:28",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "abatement",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "867",
                                             "locator" : "439:10-439:18",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    },
                                    "isTypeSpecifier" : {
                                       "localId" : "870",
                                       "locator" : "439:33-439:50",
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "localId" : "869",
                                          "locator" : "439:42-439:49",
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "then" : {
                                    "localId" : "878",
                                    "locator" : "440:4-440:62",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "874",
                                       "locator" : "440:13-440:35",
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "873",
                                          "locator" : "440:13-440:31",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "872",
                                                "locator" : "440:13-440:21",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       }
                                    },
                                    "high" : {
                                       "localId" : "877",
                                       "locator" : "440:38-440:61",
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "876",
                                          "locator" : "440:38-440:56",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "875",
                                                "locator" : "440:38-440:46",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       }
                                    }
                                 },
                                 "else" : {
                                    "type" : "Interval",
                                    "low" : {
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "low",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "882",
                                             "locator" : "441:7-441:32",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "879",
                                                "locator" : "441:7-441:10",
                                                "type" : "Null"
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "881",
                                                "locator" : "441:15-441:32",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "880",
                                                   "locator" : "441:24-441:31",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "type" : "ChoiceTypeSpecifier",
                                          "choice" : [ {
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }, {
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          } ]
                                       }
                                    },
                                    "lowClosedExpression" : {
                                       "path" : "lowClosed",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    },
                                    "high" : {
                                       "type" : "As",
                                       "operand" : {
                                          "path" : "high",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "882",
                                             "locator" : "441:7-441:32",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "879",
                                                "locator" : "441:7-441:10",
                                                "type" : "Null"
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "881",
                                                "locator" : "441:15-441:32",
                                                "type" : "IntervalTypeSpecifier",
                                                "pointType" : {
                                                   "localId" : "880",
                                                   "locator" : "441:24-441:31",
                                                   "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             }
                                          }
                                       },
                                       "asTypeSpecifier" : {
                                          "type" : "ChoiceTypeSpecifier",
                                          "choice" : [ {
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }, {
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          } ]
                                       }
                                    },
                                    "highClosedExpression" : {
                                       "path" : "highClosed",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    }
                                 }
                              }
                           }
                        }
                     }
                  },
                  "highClosedExpression" : {
                     "path" : "highClosed",
                     "type" : "Property",
                     "source" : {
                        "localId" : "885",
                        "locator" : "433:7-441:32",
                        "type" : "If",
                        "condition" : {
                           "localId" : "825",
                           "locator" : "433:10-433:47",
                           "type" : "Is",
                           "operand" : {
                              "localId" : "823",
                              "locator" : "433:10-433:28",
                              "name" : "ToValue",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "path" : "abatement",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "822",
                                    "locator" : "433:10-433:18",
                                    "name" : "condition",
                                    "type" : "OperandRef"
                                 }
                              } ]
                           },
                           "isTypeSpecifier" : {
                              "localId" : "824",
                              "locator" : "433:33-433:47",
                              "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                              "type" : "NamedTypeSpecifier"
                           }
                        },
                        "then" : {
                           "type" : "Interval",
                           "low" : {
                              "type" : "ToDateTime",
                              "operand" : {
                                 "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                 "type" : "As",
                                 "operand" : {
                                    "path" : "low",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "842",
                                       "locator" : "434:3-435:73",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "832",
                                          "locator" : "434:12-434:71",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "827",
                                             "locator" : "434:12-434:28",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "826",
                                                   "locator" : "434:12-434:18",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "831",
                                             "locator" : "434:32-434:71",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "829",
                                                "locator" : "434:33-434:51",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "828",
                                                      "locator" : "434:33-434:41",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "830",
                                                "locator" : "434:56-434:70",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "841",
                                          "locator" : "435:4-435:72",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "839",
                                             "locator" : "435:4-435:63",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "834",
                                                "locator" : "435:4-435:20",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "833",
                                                      "locator" : "435:4-435:10",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "838",
                                                "locator" : "435:24-435:63",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "836",
                                                   "locator" : "435:25-435:43",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "835",
                                                         "locator" : "435:25-435:33",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "837",
                                                   "locator" : "435:48-435:62",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "840",
                                             "locator" : "435:67-435:72",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              }
                           },
                           "lowClosedExpression" : {
                              "path" : "lowClosed",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "842",
                                 "locator" : "434:3-435:73",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "832",
                                    "locator" : "434:12-434:71",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "827",
                                       "locator" : "434:12-434:28",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "826",
                                             "locator" : "434:12-434:18",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "localId" : "831",
                                       "locator" : "434:32-434:71",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "829",
                                          "locator" : "434:33-434:51",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "828",
                                                "locator" : "434:33-434:41",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "830",
                                          "locator" : "434:56-434:70",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "841",
                                    "locator" : "435:4-435:72",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "839",
                                       "locator" : "435:4-435:63",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "834",
                                          "locator" : "435:4-435:20",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "833",
                                                "locator" : "435:4-435:10",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "838",
                                          "locator" : "435:24-435:63",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "836",
                                             "locator" : "435:25-435:43",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "835",
                                                   "locator" : "435:25-435:33",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "837",
                                             "locator" : "435:48-435:62",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "840",
                                       "locator" : "435:67-435:72",
                                       "value" : 1,
                                       "unit" : "year",
                                       "type" : "Quantity"
                                    } ]
                                 }
                              }
                           },
                           "high" : {
                              "type" : "ToDateTime",
                              "operand" : {
                                 "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                 "type" : "As",
                                 "operand" : {
                                    "path" : "high",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "842",
                                       "locator" : "434:3-435:73",
                                       "lowClosed" : true,
                                       "highClosed" : false,
                                       "type" : "Interval",
                                       "low" : {
                                          "localId" : "832",
                                          "locator" : "434:12-434:71",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "827",
                                             "locator" : "434:12-434:28",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "826",
                                                   "locator" : "434:12-434:18",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "831",
                                             "locator" : "434:32-434:71",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "829",
                                                "locator" : "434:33-434:51",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "828",
                                                      "locator" : "434:33-434:41",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "830",
                                                "locator" : "434:56-434:70",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       },
                                       "high" : {
                                          "localId" : "841",
                                          "locator" : "435:4-435:72",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "839",
                                             "locator" : "435:4-435:63",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "834",
                                                "locator" : "435:4-435:20",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "833",
                                                      "locator" : "435:4-435:10",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "838",
                                                "locator" : "435:24-435:63",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "836",
                                                   "locator" : "435:25-435:43",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "835",
                                                         "locator" : "435:25-435:33",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "837",
                                                   "locator" : "435:48-435:62",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          }, {
                                             "localId" : "840",
                                             "locator" : "435:67-435:72",
                                             "value" : 1,
                                             "unit" : "year",
                                             "type" : "Quantity"
                                          } ]
                                       }
                                    }
                                 }
                              }
                           },
                           "highClosedExpression" : {
                              "path" : "highClosed",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "842",
                                 "locator" : "434:3-435:73",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "832",
                                    "locator" : "434:12-434:71",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "827",
                                       "locator" : "434:12-434:28",
                                       "path" : "value",
                                       "type" : "Property",
                                       "source" : {
                                          "path" : "birthDate",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "826",
                                             "locator" : "434:12-434:18",
                                             "name" : "Patient",
                                             "type" : "ExpressionRef"
                                          }
                                       }
                                    }, {
                                       "localId" : "831",
                                       "locator" : "434:32-434:71",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "829",
                                          "locator" : "434:33-434:51",
                                          "name" : "ToValue",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "abatement",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "828",
                                                "locator" : "434:33-434:41",
                                                "name" : "condition",
                                                "type" : "OperandRef"
                                             }
                                          } ]
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "830",
                                          "locator" : "434:56-434:70",
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 },
                                 "high" : {
                                    "localId" : "841",
                                    "locator" : "435:4-435:72",
                                    "type" : "Add",
                                    "operand" : [ {
                                       "localId" : "839",
                                       "locator" : "435:4-435:63",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "834",
                                          "locator" : "435:4-435:20",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "833",
                                                "locator" : "435:4-435:10",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "838",
                                          "locator" : "435:24-435:63",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "836",
                                             "locator" : "435:25-435:43",
                                             "name" : "ToValue",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "abatement",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "835",
                                                   "locator" : "435:25-435:33",
                                                   "name" : "condition",
                                                   "type" : "OperandRef"
                                                }
                                             } ]
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "837",
                                             "locator" : "435:48-435:62",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    }, {
                                       "localId" : "840",
                                       "locator" : "435:67-435:72",
                                       "value" : 1,
                                       "unit" : "year",
                                       "type" : "Quantity"
                                    } ]
                                 }
                              }
                           }
                        },
                        "else" : {
                           "localId" : "884",
                           "locator" : "436:7-441:32",
                           "type" : "If",
                           "condition" : {
                              "localId" : "847",
                              "locator" : "436:10-436:57",
                              "type" : "Is",
                              "operand" : {
                                 "localId" : "844",
                                 "locator" : "436:10-436:28",
                                 "name" : "ToValue",
                                 "libraryName" : "FHIRHelpers",
                                 "type" : "FunctionRef",
                                 "operand" : [ {
                                    "path" : "abatement",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "843",
                                       "locator" : "436:10-436:18",
                                       "name" : "condition",
                                       "type" : "OperandRef"
                                    }
                                 } ]
                              },
                              "isTypeSpecifier" : {
                                 "localId" : "846",
                                 "locator" : "436:33-436:57",
                                 "type" : "IntervalTypeSpecifier",
                                 "pointType" : {
                                    "localId" : "845",
                                    "locator" : "436:42-436:56",
                                    "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                    "type" : "NamedTypeSpecifier"
                                 }
                              }
                           },
                           "then" : {
                              "type" : "Interval",
                              "low" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "866",
                                          "locator" : "437:4-438:79",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "855",
                                             "locator" : "437:13-437:76",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "849",
                                                "locator" : "437:13-437:29",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "848",
                                                      "locator" : "437:13-437:19",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "854",
                                                "locator" : "437:33-437:76",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "852",
                                                   "locator" : "437:34-437:56",
                                                   "path" : "low",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "851",
                                                      "locator" : "437:34-437:52",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "850",
                                                            "locator" : "437:34-437:42",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "853",
                                                   "locator" : "437:61-437:75",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "865",
                                             "locator" : "438:5-438:78",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "863",
                                                "locator" : "438:5-438:69",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "857",
                                                   "locator" : "438:5-438:21",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "856",
                                                         "locator" : "438:5-438:11",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "862",
                                                   "locator" : "438:25-438:69",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "860",
                                                      "locator" : "438:26-438:49",
                                                      "path" : "high",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "859",
                                                         "locator" : "438:26-438:44",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "858",
                                                               "locator" : "438:26-438:34",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "861",
                                                      "locator" : "438:54-438:68",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "864",
                                                "locator" : "438:73-438:78",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "lowClosedExpression" : {
                                 "path" : "lowClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "866",
                                    "locator" : "437:4-438:79",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "855",
                                       "locator" : "437:13-437:76",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "849",
                                          "locator" : "437:13-437:29",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "848",
                                                "locator" : "437:13-437:19",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "854",
                                          "locator" : "437:33-437:76",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "852",
                                             "locator" : "437:34-437:56",
                                             "path" : "low",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "851",
                                                "locator" : "437:34-437:52",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "850",
                                                      "locator" : "437:34-437:42",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "853",
                                             "locator" : "437:61-437:75",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "865",
                                       "locator" : "438:5-438:78",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "863",
                                          "locator" : "438:5-438:69",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "857",
                                             "locator" : "438:5-438:21",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "856",
                                                   "locator" : "438:5-438:11",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "862",
                                             "locator" : "438:25-438:69",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "860",
                                                "locator" : "438:26-438:49",
                                                "path" : "high",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "859",
                                                   "locator" : "438:26-438:44",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "858",
                                                         "locator" : "438:26-438:34",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "861",
                                                "locator" : "438:54-438:68",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "864",
                                          "locator" : "438:73-438:78",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              },
                              "high" : {
                                 "type" : "ToDateTime",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}Date",
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "866",
                                          "locator" : "437:4-438:79",
                                          "lowClosed" : true,
                                          "highClosed" : false,
                                          "type" : "Interval",
                                          "low" : {
                                             "localId" : "855",
                                             "locator" : "437:13-437:76",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "849",
                                                "locator" : "437:13-437:29",
                                                "path" : "value",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "birthDate",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "848",
                                                      "locator" : "437:13-437:19",
                                                      "name" : "Patient",
                                                      "type" : "ExpressionRef"
                                                   }
                                                }
                                             }, {
                                                "localId" : "854",
                                                "locator" : "437:33-437:76",
                                                "strict" : false,
                                                "type" : "As",
                                                "operand" : {
                                                   "localId" : "852",
                                                   "locator" : "437:34-437:56",
                                                   "path" : "low",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "851",
                                                      "locator" : "437:34-437:52",
                                                      "name" : "ToValue",
                                                      "libraryName" : "FHIRHelpers",
                                                      "type" : "FunctionRef",
                                                      "operand" : [ {
                                                         "path" : "abatement",
                                                         "type" : "Property",
                                                         "source" : {
                                                            "localId" : "850",
                                                            "locator" : "437:34-437:42",
                                                            "name" : "condition",
                                                            "type" : "OperandRef"
                                                         }
                                                      } ]
                                                   }
                                                },
                                                "asTypeSpecifier" : {
                                                   "localId" : "853",
                                                   "locator" : "437:61-437:75",
                                                   "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                   "type" : "NamedTypeSpecifier"
                                                }
                                             } ]
                                          },
                                          "high" : {
                                             "localId" : "865",
                                             "locator" : "438:5-438:78",
                                             "type" : "Add",
                                             "operand" : [ {
                                                "localId" : "863",
                                                "locator" : "438:5-438:69",
                                                "type" : "Add",
                                                "operand" : [ {
                                                   "localId" : "857",
                                                   "locator" : "438:5-438:21",
                                                   "path" : "value",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "birthDate",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "856",
                                                         "locator" : "438:5-438:11",
                                                         "name" : "Patient",
                                                         "type" : "ExpressionRef"
                                                      }
                                                   }
                                                }, {
                                                   "localId" : "862",
                                                   "locator" : "438:25-438:69",
                                                   "strict" : false,
                                                   "type" : "As",
                                                   "operand" : {
                                                      "localId" : "860",
                                                      "locator" : "438:26-438:49",
                                                      "path" : "high",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "859",
                                                         "locator" : "438:26-438:44",
                                                         "name" : "ToValue",
                                                         "libraryName" : "FHIRHelpers",
                                                         "type" : "FunctionRef",
                                                         "operand" : [ {
                                                            "path" : "abatement",
                                                            "type" : "Property",
                                                            "source" : {
                                                               "localId" : "858",
                                                               "locator" : "438:26-438:34",
                                                               "name" : "condition",
                                                               "type" : "OperandRef"
                                                            }
                                                         } ]
                                                      }
                                                   },
                                                   "asTypeSpecifier" : {
                                                      "localId" : "861",
                                                      "locator" : "438:54-438:68",
                                                      "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                      "type" : "NamedTypeSpecifier"
                                                   }
                                                } ]
                                             }, {
                                                "localId" : "864",
                                                "locator" : "438:73-438:78",
                                                "value" : 1,
                                                "unit" : "year",
                                                "type" : "Quantity"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              },
                              "highClosedExpression" : {
                                 "path" : "highClosed",
                                 "type" : "Property",
                                 "source" : {
                                    "localId" : "866",
                                    "locator" : "437:4-438:79",
                                    "lowClosed" : true,
                                    "highClosed" : false,
                                    "type" : "Interval",
                                    "low" : {
                                       "localId" : "855",
                                       "locator" : "437:13-437:76",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "849",
                                          "locator" : "437:13-437:29",
                                          "path" : "value",
                                          "type" : "Property",
                                          "source" : {
                                             "path" : "birthDate",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "848",
                                                "locator" : "437:13-437:19",
                                                "name" : "Patient",
                                                "type" : "ExpressionRef"
                                             }
                                          }
                                       }, {
                                          "localId" : "854",
                                          "locator" : "437:33-437:76",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "852",
                                             "locator" : "437:34-437:56",
                                             "path" : "low",
                                             "type" : "Property",
                                             "source" : {
                                                "localId" : "851",
                                                "locator" : "437:34-437:52",
                                                "name" : "ToValue",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "abatement",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "localId" : "850",
                                                      "locator" : "437:34-437:42",
                                                      "name" : "condition",
                                                      "type" : "OperandRef"
                                                   }
                                                } ]
                                             }
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "853",
                                             "locator" : "437:61-437:75",
                                             "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       } ]
                                    },
                                    "high" : {
                                       "localId" : "865",
                                       "locator" : "438:5-438:78",
                                       "type" : "Add",
                                       "operand" : [ {
                                          "localId" : "863",
                                          "locator" : "438:5-438:69",
                                          "type" : "Add",
                                          "operand" : [ {
                                             "localId" : "857",
                                             "locator" : "438:5-438:21",
                                             "path" : "value",
                                             "type" : "Property",
                                             "source" : {
                                                "path" : "birthDate",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "856",
                                                   "locator" : "438:5-438:11",
                                                   "name" : "Patient",
                                                   "type" : "ExpressionRef"
                                                }
                                             }
                                          }, {
                                             "localId" : "862",
                                             "locator" : "438:25-438:69",
                                             "strict" : false,
                                             "type" : "As",
                                             "operand" : {
                                                "localId" : "860",
                                                "locator" : "438:26-438:49",
                                                "path" : "high",
                                                "type" : "Property",
                                                "source" : {
                                                   "localId" : "859",
                                                   "locator" : "438:26-438:44",
                                                   "name" : "ToValue",
                                                   "libraryName" : "FHIRHelpers",
                                                   "type" : "FunctionRef",
                                                   "operand" : [ {
                                                      "path" : "abatement",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "localId" : "858",
                                                         "locator" : "438:26-438:34",
                                                         "name" : "condition",
                                                         "type" : "OperandRef"
                                                      }
                                                   } ]
                                                }
                                             },
                                             "asTypeSpecifier" : {
                                                "localId" : "861",
                                                "locator" : "438:54-438:68",
                                                "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          } ]
                                       }, {
                                          "localId" : "864",
                                          "locator" : "438:73-438:78",
                                          "value" : 1,
                                          "unit" : "year",
                                          "type" : "Quantity"
                                       } ]
                                    }
                                 }
                              }
                           },
                           "else" : {
                              "localId" : "883",
                              "locator" : "439:7-441:32",
                              "type" : "If",
                              "condition" : {
                                 "localId" : "871",
                                 "locator" : "439:10-439:50",
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "868",
                                    "locator" : "439:10-439:28",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "abatement",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "867",
                                          "locator" : "439:10-439:18",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "localId" : "870",
                                    "locator" : "439:33-439:50",
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "localId" : "869",
                                       "locator" : "439:42-439:49",
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "localId" : "878",
                                 "locator" : "440:4-440:62",
                                 "lowClosed" : true,
                                 "highClosed" : false,
                                 "type" : "Interval",
                                 "low" : {
                                    "localId" : "874",
                                    "locator" : "440:13-440:35",
                                    "path" : "low",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "873",
                                       "locator" : "440:13-440:31",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "abatement",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "872",
                                             "locator" : "440:13-440:21",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 },
                                 "high" : {
                                    "localId" : "877",
                                    "locator" : "440:38-440:61",
                                    "path" : "high",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "876",
                                       "locator" : "440:38-440:56",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "abatement",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "875",
                                             "locator" : "440:38-440:46",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 }
                              },
                              "else" : {
                                 "type" : "Interval",
                                 "low" : {
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "low",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "type" : "ChoiceTypeSpecifier",
                                       "choice" : [ {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       } ]
                                    }
                                 },
                                 "lowClosedExpression" : {
                                    "path" : "lowClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "882",
                                       "locator" : "441:7-441:32",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "879",
                                          "locator" : "441:7-441:10",
                                          "type" : "Null"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "881",
                                          "locator" : "441:15-441:32",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "880",
                                             "locator" : "441:24-441:31",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    }
                                 },
                                 "high" : {
                                    "type" : "As",
                                    "operand" : {
                                       "path" : "high",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "882",
                                          "locator" : "441:7-441:32",
                                          "strict" : false,
                                          "type" : "As",
                                          "operand" : {
                                             "localId" : "879",
                                             "locator" : "441:7-441:10",
                                             "type" : "Null"
                                          },
                                          "asTypeSpecifier" : {
                                             "localId" : "881",
                                             "locator" : "441:15-441:32",
                                             "type" : "IntervalTypeSpecifier",
                                             "pointType" : {
                                                "localId" : "880",
                                                "locator" : "441:24-441:31",
                                                "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                                "type" : "NamedTypeSpecifier"
                                             }
                                          }
                                       }
                                    },
                                    "asTypeSpecifier" : {
                                       "type" : "ChoiceTypeSpecifier",
                                       "choice" : [ {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }, {
                                          "name" : "{urn:hl7-org:elm-types:r1}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       } ]
                                    }
                                 },
                                 "highClosedExpression" : {
                                    "path" : "highClosed",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "882",
                                       "locator" : "441:7-441:32",
                                       "strict" : false,
                                       "type" : "As",
                                       "operand" : {
                                          "localId" : "879",
                                          "locator" : "441:7-441:10",
                                          "type" : "Null"
                                       },
                                       "asTypeSpecifier" : {
                                          "localId" : "881",
                                          "locator" : "441:15-441:32",
                                          "type" : "IntervalTypeSpecifier",
                                          "pointType" : {
                                             "localId" : "880",
                                             "locator" : "441:24-441:31",
                                             "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                             "type" : "NamedTypeSpecifier"
                                          }
                                       }
                                    }
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "808",
                  "locator" : "430:52-430:67",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "920",
            "locator" : "449:1-455:87",
            "name" : "prevalenceInterval",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns an interval representing the normalized prevalence period of a given Condition."
               }, {
                  "name" : "comment",
                  "value" : "Uses the toInterval and abatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, the resulting interval will have\na closed ending boundary. If the condition is not active, the resulting interval will have an open ending boundary."
               } ],
               "s" : {
                  "r" : "920",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns an interval representing the normalized prevalence period of a given Condition.\n@comment: Uses the toInterval and abatementInterval functions to determine the widest potential interval from\nonset to abatement as specified in the given Condition. If the condition is active, the resulting interval will have\na closed ending boundary. If the condition is not active, the resulting interval will have an open ending boundary.\n*/\n","define fluent function ","prevalenceInterval","(","condition"," " ]
                  }, {
                     "r" : "888",
                     "s" : [ {
                        "value" : [ "USCore",".","Condition" ]
                     } ]
                  }, {
                     "value" : [ "):\n" ]
                  }, {
                     "r" : "919",
                     "s" : [ {
                        "r" : "919",
                        "s" : [ {
                           "value" : [ "if " ]
                        }, {
                           "r" : "902",
                           "s" : [ {
                              "r" : "897",
                              "s" : [ {
                                 "r" : "892",
                                 "s" : [ {
                                    "r" : "890",
                                    "s" : [ {
                                       "r" : "889",
                                       "s" : [ {
                                          "value" : [ "condition" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "890",
                                       "s" : [ {
                                          "value" : [ "clinicalStatus" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "891",
                                    "s" : [ {
                                       "value" : [ "\"active\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n  or " ]
                              }, {
                                 "r" : "896",
                                 "s" : [ {
                                    "r" : "894",
                                    "s" : [ {
                                       "r" : "893",
                                       "s" : [ {
                                          "value" : [ "condition" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "894",
                                       "s" : [ {
                                          "value" : [ "clinicalStatus" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "895",
                                    "s" : [ {
                                       "value" : [ "\"recurrence\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  or " ]
                           }, {
                              "r" : "901",
                              "s" : [ {
                                 "r" : "899",
                                 "s" : [ {
                                    "r" : "898",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "899",
                                    "s" : [ {
                                       "value" : [ "clinicalStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "900",
                                 "s" : [ {
                                    "value" : [ "\"relapse\"" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ " then\n  " ]
                        }, {
                           "r" : "910",
                           "s" : [ {
                              "value" : [ "Interval[" ]
                           }, {
                              "r" : "906",
                              "s" : [ {
                                 "value" : [ "start of " ]
                              }, {
                                 "r" : "905",
                                 "s" : [ {
                                    "r" : "904",
                                    "s" : [ {
                                       "r" : "903",
                                       "s" : [ {
                                          "value" : [ "condition" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "904",
                                       "s" : [ {
                                          "value" : [ "onset" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "905",
                                    "s" : [ {
                                       "value" : [ "toInterval","()" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "909",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "908",
                                 "s" : [ {
                                    "r" : "907",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "908",
                                    "s" : [ {
                                       "value" : [ "abatementInterval","()" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "]" ]
                           } ]
                        }, {
                           "value" : [ "\nelse\n  " ]
                        }, {
                           "r" : "918",
                           "s" : [ {
                              "value" : [ "Interval[" ]
                           }, {
                              "r" : "914",
                              "s" : [ {
                                 "value" : [ "start of " ]
                              }, {
                                 "r" : "913",
                                 "s" : [ {
                                    "r" : "912",
                                    "s" : [ {
                                       "r" : "911",
                                       "s" : [ {
                                          "value" : [ "condition" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "912",
                                       "s" : [ {
                                          "value" : [ "onset" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "913",
                                    "s" : [ {
                                       "value" : [ "toInterval","()" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "917",
                              "s" : [ {
                                 "value" : [ "end of " ]
                              }, {
                                 "r" : "916",
                                 "s" : [ {
                                    "r" : "915",
                                    "s" : [ {
                                       "value" : [ "condition" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "916",
                                    "s" : [ {
                                       "value" : [ "abatementInterval","()" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "919",
               "locator" : "450:1-455:87",
               "type" : "If",
               "condition" : {
                  "localId" : "902",
                  "locator" : "450:4-452:41",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "897",
                     "locator" : "450:4-451:44",
                     "type" : "Or",
                     "operand" : [ {
                        "localId" : "892",
                        "locator" : "450:4-450:38",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "890",
                           "locator" : "450:4-450:27",
                           "name" : "ToConcept",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "clinicalStatus",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "889",
                                 "locator" : "450:4-450:12",
                                 "name" : "condition",
                                 "type" : "OperandRef"
                              }
                           } ]
                        }, {
                           "type" : "ToConcept",
                           "operand" : {
                              "localId" : "891",
                              "locator" : "450:31-450:38",
                              "name" : "active",
                              "type" : "CodeRef"
                           }
                        } ]
                     }, {
                        "localId" : "896",
                        "locator" : "451:6-451:44",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "894",
                           "locator" : "451:6-451:29",
                           "name" : "ToConcept",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "clinicalStatus",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "893",
                                 "locator" : "451:6-451:14",
                                 "name" : "condition",
                                 "type" : "OperandRef"
                              }
                           } ]
                        }, {
                           "type" : "ToConcept",
                           "operand" : {
                              "localId" : "895",
                              "locator" : "451:33-451:44",
                              "name" : "recurrence",
                              "type" : "CodeRef"
                           }
                        } ]
                     } ]
                  }, {
                     "localId" : "901",
                     "locator" : "452:6-452:41",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "899",
                        "locator" : "452:6-452:29",
                        "name" : "ToConcept",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "clinicalStatus",
                           "type" : "Property",
                           "source" : {
                              "localId" : "898",
                              "locator" : "452:6-452:14",
                              "name" : "condition",
                              "type" : "OperandRef"
                           }
                        } ]
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "900",
                           "locator" : "452:33-452:41",
                           "name" : "relapse",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               },
               "then" : {
                  "localId" : "910",
                  "locator" : "453:3-453:87",
                  "lowClosed" : true,
                  "highClosed" : true,
                  "type" : "Interval",
                  "low" : {
                     "localId" : "906",
                     "locator" : "453:12-453:48",
                     "type" : "Start",
                     "operand" : {
                        "localId" : "905",
                        "locator" : "453:21-453:48",
                        "name" : "toInterval",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "type" : "Case",
                           "caseItem" : [ {
                              "when" : {
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "904",
                                    "locator" : "453:21-453:35",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "onset",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "903",
                                          "locator" : "453:21-453:29",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 }
                              },
                              "then" : {
                                 "type" : "As",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "904",
                                       "locator" : "453:21-453:35",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "onset",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "903",
                                             "locator" : "453:21-453:29",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "type" : "ChoiceTypeSpecifier",
                                    "choice" : [ {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "when" : {
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "904",
                                    "locator" : "453:21-453:35",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "onset",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "903",
                                          "locator" : "453:21-453:29",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "type" : "As",
                                 "operand" : {
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "904",
                                       "locator" : "453:21-453:35",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "onset",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "903",
                                             "locator" : "453:21-453:29",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    },
                                    "asTypeSpecifier" : {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "type" : "ChoiceTypeSpecifier",
                                    "choice" : [ {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           } ],
                           "else" : {
                              "type" : "Null",
                              "resultTypeSpecifier" : {
                                 "type" : "ChoiceTypeSpecifier",
                                 "choice" : [ {
                                    "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "NamedTypeSpecifier"
                                 }, {
                                    "name" : "{http://hl7.org/fhir}Quantity",
                                    "type" : "NamedTypeSpecifier"
                                 }, {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }, {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              }
                           }
                        } ]
                     }
                  },
                  "high" : {
                     "localId" : "909",
                     "locator" : "453:51-453:86",
                     "type" : "End",
                     "operand" : {
                        "localId" : "908",
                        "locator" : "453:58-453:86",
                        "name" : "abatementInterval",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "907",
                           "locator" : "453:58-453:66",
                           "name" : "condition",
                           "type" : "OperandRef"
                        } ]
                     }
                  }
               },
               "else" : {
                  "localId" : "918",
                  "locator" : "455:3-455:87",
                  "lowClosed" : true,
                  "highClosed" : false,
                  "type" : "Interval",
                  "low" : {
                     "localId" : "914",
                     "locator" : "455:12-455:48",
                     "type" : "Start",
                     "operand" : {
                        "localId" : "913",
                        "locator" : "455:21-455:48",
                        "name" : "toInterval",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "type" : "Case",
                           "caseItem" : [ {
                              "when" : {
                                 "isType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "912",
                                    "locator" : "455:21-455:35",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "onset",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "911",
                                          "locator" : "455:21-455:29",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 }
                              },
                              "then" : {
                                 "type" : "As",
                                 "operand" : {
                                    "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "912",
                                       "locator" : "455:21-455:35",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "onset",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "911",
                                             "locator" : "455:21-455:29",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "type" : "ChoiceTypeSpecifier",
                                    "choice" : [ {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           }, {
                              "when" : {
                                 "type" : "Is",
                                 "operand" : {
                                    "localId" : "912",
                                    "locator" : "455:21-455:35",
                                    "name" : "ToValue",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "onset",
                                       "type" : "Property",
                                       "source" : {
                                          "localId" : "911",
                                          "locator" : "455:21-455:29",
                                          "name" : "condition",
                                          "type" : "OperandRef"
                                       }
                                    } ]
                                 },
                                 "isTypeSpecifier" : {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }
                              },
                              "then" : {
                                 "type" : "As",
                                 "operand" : {
                                    "type" : "As",
                                    "operand" : {
                                       "localId" : "912",
                                       "locator" : "455:21-455:35",
                                       "name" : "ToValue",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "onset",
                                          "type" : "Property",
                                          "source" : {
                                             "localId" : "911",
                                             "locator" : "455:21-455:29",
                                             "name" : "condition",
                                             "type" : "OperandRef"
                                          }
                                       } ]
                                    },
                                    "asTypeSpecifier" : {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }
                                 },
                                 "asTypeSpecifier" : {
                                    "type" : "ChoiceTypeSpecifier",
                                    "choice" : [ {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    }, {
                                       "type" : "IntervalTypeSpecifier",
                                       "pointType" : {
                                          "name" : "{http://hl7.org/fhir}Quantity",
                                          "type" : "NamedTypeSpecifier"
                                       }
                                    } ]
                                 }
                              }
                           } ],
                           "else" : {
                              "type" : "Null",
                              "resultTypeSpecifier" : {
                                 "type" : "ChoiceTypeSpecifier",
                                 "choice" : [ {
                                    "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                    "type" : "NamedTypeSpecifier"
                                 }, {
                                    "name" : "{http://hl7.org/fhir}Quantity",
                                    "type" : "NamedTypeSpecifier"
                                 }, {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 }, {
                                    "type" : "IntervalTypeSpecifier",
                                    "pointType" : {
                                       "name" : "{http://hl7.org/fhir}Quantity",
                                       "type" : "NamedTypeSpecifier"
                                    }
                                 } ]
                              }
                           }
                        } ]
                     }
                  },
                  "high" : {
                     "localId" : "917",
                     "locator" : "455:51-455:86",
                     "type" : "End",
                     "operand" : {
                        "localId" : "916",
                        "locator" : "455:58-455:86",
                        "name" : "abatementInterval",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "915",
                           "locator" : "455:58-455:66",
                           "name" : "condition",
                           "type" : "OperandRef"
                        } ]
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "condition",
               "operandTypeSpecifier" : {
                  "localId" : "888",
                  "locator" : "449:53-449:68",
                  "name" : "{http://hl7.org/fhir}Condition",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "926",
            "locator" : "463:1-464:23",
            "name" : "getId",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns the tail of the given uri (i.e. everything after the last slash in the URI)."
               }, {
                  "name" : "comment",
                  "value" : "This function can be used to determine the logical id of a given resource. It can be used in\na single-server environment to trace references. However, this function does not attempt to resolve\nor distinguish the base of the given url, and so cannot be used safely in multi-server environments."
               } ],
               "s" : {
                  "r" : "926",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns the tail of the given uri (i.e. everything after the last slash in the URI).\n@comment: This function can be used to determine the logical id of a given resource. It can be used in\na single-server environment to trace references. However, this function does not attempt to resolve\nor distinguish the base of the given url, and so cannot be used safely in multi-server environments.\n*/\n","define fluent function ","getId","(","uri"," " ]
                  }, {
                     "r" : "921",
                     "s" : [ {
                        "value" : [ "String" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "925",
                     "s" : [ {
                        "r" : "925",
                        "s" : [ {
                           "value" : [ "Last","(" ]
                        }, {
                           "r" : "924",
                           "s" : [ {
                              "value" : [ "Split","(" ]
                           }, {
                              "r" : "922",
                              "s" : [ {
                                 "value" : [ "uri" ]
                              } ]
                           }, {
                              "value" : [ ", " ]
                           }, {
                              "r" : "923",
                              "s" : [ {
                                 "value" : [ "'/'" ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "925",
               "locator" : "464:3-464:23",
               "type" : "Last",
               "source" : {
                  "localId" : "924",
                  "locator" : "464:8-464:22",
                  "type" : "Split",
                  "stringToSplit" : {
                     "localId" : "922",
                     "locator" : "464:14-464:16",
                     "name" : "uri",
                     "type" : "OperandRef"
                  },
                  "separator" : {
                     "localId" : "923",
                     "locator" : "464:19-464:21",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "/",
                     "type" : "Literal"
                  }
               }
            },
            "operand" : [ {
               "name" : "uri",
               "operandTypeSpecifier" : {
                  "localId" : "921",
                  "locator" : "463:34-463:39",
                  "name" : "{urn:hl7-org:elm-types:r1}String",
                  "type" : "NamedTypeSpecifier"
               }
            } ]
         }, {
            "localId" : "939",
            "locator" : "470:1-473:3",
            "name" : "hasStart",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Given an interval, return true if the interval has a starting boundary specified\n(i.e. the start of the interval is not null and not the minimum DateTime value)"
               } ],
               "s" : {
                  "r" : "939",
                  "s" : [ {
                     "value" : [ "/*\n@description: Given an interval, return true if the interval has a starting boundary specified\n(i.e. the start of the interval is not null and not the minimum DateTime value)\n*/\n","define fluent function ","hasStart","(","period"," " ]
                  }, {
                     "r" : "928",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "927",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ " ):\n  " ]
                  }, {
                     "r" : "938",
                     "s" : [ {
                        "r" : "938",
                        "s" : [ {
                           "value" : [ "not " ]
                        }, {
                           "r" : "937",
                           "s" : [ {
                              "value" : [ "( " ]
                           }, {
                              "r" : "937",
                              "s" : [ {
                                 "r" : "931",
                                 "s" : [ {
                                    "r" : "930",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "929",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " is null" ]
                                 } ]
                              }, {
                                 "value" : [ "\n      or " ]
                              }, {
                                 "r" : "936",
                                 "s" : [ {
                                    "r" : "933",
                                    "s" : [ {
                                       "value" : [ "start of " ]
                                    }, {
                                       "r" : "932",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","="," " ]
                                 }, {
                                    "r" : "935",
                                    "s" : [ {
                                       "value" : [ "minimum"," " ]
                                    }, {
                                       "r" : "934",
                                       "s" : [ {
                                          "value" : [ "DateTime" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "938",
               "locator" : "471:3-473:3",
               "type" : "Not",
               "operand" : {
                  "localId" : "937",
                  "locator" : "471:7-473:3",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "931",
                     "locator" : "471:9-471:31",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "930",
                        "locator" : "471:9-471:23",
                        "type" : "Start",
                        "operand" : {
                           "localId" : "929",
                           "locator" : "471:18-471:23",
                           "name" : "period",
                           "type" : "OperandRef"
                        }
                     }
                  }, {
                     "localId" : "936",
                     "locator" : "472:10-472:43",
                     "type" : "Equal",
                     "operand" : [ {
                        "localId" : "933",
                        "locator" : "472:10-472:24",
                        "type" : "Start",
                        "operand" : {
                           "localId" : "932",
                           "locator" : "472:19-472:24",
                           "name" : "period",
                           "type" : "OperandRef"
                        }
                     }, {
                        "localId" : "935",
                        "locator" : "472:28-472:43",
                        "valueType" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "MinValue"
                     } ]
                  } ]
               }
            },
            "operand" : [ {
               "name" : "period",
               "operandTypeSpecifier" : {
                  "localId" : "928",
                  "locator" : "470:40-470:57",
                  "type" : "IntervalTypeSpecifier",
                  "pointType" : {
                     "localId" : "927",
                     "locator" : "470:49-470:56",
                     "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "952",
            "locator" : "479:1-483:3",
            "name" : "hasEnd",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Given an interval, returns true if the interval has an ending boundary specified\n(i.e. the end of the interval is not null and not the maximum DateTime value)"
               } ],
               "s" : {
                  "r" : "952",
                  "s" : [ {
                     "value" : [ "/*\n@description: Given an interval, returns true if the interval has an ending boundary specified\n(i.e. the end of the interval is not null and not the maximum DateTime value)\n*/\n","define fluent function ","hasEnd","(","period"," " ]
                  }, {
                     "r" : "941",
                     "s" : [ {
                        "value" : [ "Interval<" ]
                     }, {
                        "r" : "940",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ " ):\n  " ]
                  }, {
                     "r" : "951",
                     "s" : [ {
                        "r" : "951",
                        "s" : [ {
                           "value" : [ "not " ]
                        }, {
                           "r" : "950",
                           "s" : [ {
                              "value" : [ "(\n    " ]
                           }, {
                              "r" : "950",
                              "s" : [ {
                                 "r" : "944",
                                 "s" : [ {
                                    "r" : "943",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "942",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " is null" ]
                                 } ]
                              }, {
                                 "value" : [ "\n      or " ]
                              }, {
                                 "r" : "949",
                                 "s" : [ {
                                    "r" : "946",
                                    "s" : [ {
                                       "value" : [ "end of " ]
                                    }, {
                                       "r" : "945",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","="," " ]
                                 }, {
                                    "r" : "948",
                                    "s" : [ {
                                       "value" : [ "maximum"," " ]
                                    }, {
                                       "r" : "947",
                                       "s" : [ {
                                          "value" : [ "DateTime" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n  )" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "951",
               "locator" : "480:3-483:3",
               "type" : "Not",
               "operand" : {
                  "localId" : "950",
                  "locator" : "480:7-483:3",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "944",
                     "locator" : "481:5-481:25",
                     "type" : "IsNull",
                     "operand" : {
                        "localId" : "943",
                        "locator" : "481:5-481:17",
                        "type" : "End",
                        "operand" : {
                           "localId" : "942",
                           "locator" : "481:12-481:17",
                           "name" : "period",
                           "type" : "OperandRef"
                        }
                     }
                  }, {
                     "localId" : "949",
                     "locator" : "482:10-482:41",
                     "type" : "Equal",
                     "operand" : [ {
                        "localId" : "946",
                        "locator" : "482:10-482:22",
                        "type" : "End",
                        "operand" : {
                           "localId" : "945",
                           "locator" : "482:17-482:22",
                           "name" : "period",
                           "type" : "OperandRef"
                        }
                     }, {
                        "localId" : "948",
                        "locator" : "482:26-482:41",
                        "valueType" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "MaxValue"
                     } ]
                  } ]
               }
            },
            "operand" : [ {
               "name" : "period",
               "operandTypeSpecifier" : {
                  "localId" : "941",
                  "locator" : "479:38-479:55",
                  "type" : "IntervalTypeSpecifier",
                  "pointType" : {
                     "localId" : "940",
                     "locator" : "479:47-479:54",
                     "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "972",
            "locator" : "489:1-493:26",
            "name" : "latest",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Given an interval, returns the ending point if the interval has an ending boundary specified,\notherwise, returns the starting point"
               } ],
               "s" : {
                  "r" : "972",
                  "s" : [ {
                     "value" : [ "/*\n@description: Given an interval, returns the ending point if the interval has an ending boundary specified,\notherwise, returns the starting point\n*/\n","define fluent function ","latest","(","choice"," " ]
                  }, {
                     "r" : "959",
                     "s" : [ {
                        "value" : [ "Choice<" ]
                     }, {
                        "r" : "953",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "954",
                        "s" : [ {
                           "value" : [ "Quantity" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "956",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "955",
                           "s" : [ {
                              "value" : [ "DateTime" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "958",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "957",
                           "s" : [ {
                              "value" : [ "Quantity" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ " ):\n  " ]
                  }, {
                     "r" : "971",
                     "s" : [ {
                        "r" : "971",
                        "s" : [ {
                           "s" : [ {
                              "r" : "962",
                              "s" : [ {
                                 "r" : "961",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "961",
                                    "s" : [ {
                                       "r" : "960",
                                       "s" : [ {
                                          "value" : [ "choice" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "961",
                                       "s" : [ {
                                          "value" : [ "toInterval","()" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ " ","period" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "970",
                           "s" : [ {
                              "value" : [ "return\n      " ]
                           }, {
                              "r" : "969",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "964",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "964",
                                    "s" : [ {
                                       "r" : "963",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "964",
                                       "s" : [ {
                                          "value" : [ "hasEnd","()" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ " then " ]
                              }, {
                                 "r" : "966",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "965",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      else " ]
                              }, {
                                 "r" : "968",
                                 "s" : [ {
                                    "value" : [ "start of " ]
                                 }, {
                                    "r" : "967",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "971",
               "locator" : "490:3-493:26",
               "type" : "Query",
               "source" : [ {
                  "localId" : "962",
                  "locator" : "490:3-490:30",
                  "alias" : "period",
                  "expression" : {
                     "localId" : "961",
                     "locator" : "490:3-490:23",
                     "name" : "toInterval",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "960",
                        "locator" : "490:4-490:9",
                        "name" : "choice",
                        "type" : "OperandRef"
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "970",
                  "locator" : "491:5-493:26",
                  "expression" : {
                     "localId" : "969",
                     "locator" : "492:7-493:26",
                     "type" : "If",
                     "condition" : {
                        "localId" : "964",
                        "locator" : "492:10-492:26",
                        "name" : "hasEnd",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "963",
                           "locator" : "492:11-492:16",
                           "name" : "period",
                           "type" : "AliasRef"
                        } ]
                     },
                     "then" : {
                        "localId" : "966",
                        "locator" : "492:33-492:45",
                        "type" : "End",
                        "operand" : {
                           "localId" : "965",
                           "locator" : "492:40-492:45",
                           "name" : "period",
                           "type" : "AliasRef"
                        }
                     },
                     "else" : {
                        "localId" : "968",
                        "locator" : "493:12-493:26",
                        "type" : "Start",
                        "operand" : {
                           "localId" : "967",
                           "locator" : "493:21-493:26",
                           "name" : "period",
                           "type" : "AliasRef"
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "choice",
               "operandTypeSpecifier" : {
                  "localId" : "959",
                  "locator" : "489:38-489:103",
                  "type" : "ChoiceTypeSpecifier",
                  "choice" : [ {
                     "localId" : "953",
                     "locator" : "489:45-489:52",
                     "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "954",
                     "locator" : "489:55-489:62",
                     "name" : "{http://hl7.org/fhir}Quantity",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "956",
                     "locator" : "489:65-489:82",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "955",
                        "locator" : "489:74-489:81",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }, {
                     "localId" : "958",
                     "locator" : "489:85-489:102",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "957",
                        "locator" : "489:94-489:101",
                        "name" : "{http://hl7.org/fhir}Quantity",
                        "type" : "NamedTypeSpecifier"
                     }
                  } ]
               }
            } ]
         }, {
            "localId" : "992",
            "locator" : "499:1-503:24",
            "name" : "earliest",
            "context" : "Patient",
            "accessLevel" : "Public",
            "fluent" : true,
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Given an interval, return the starting point if the interval has a starting boundary specified,\notherwise, return the ending point"
               } ],
               "s" : {
                  "r" : "992",
                  "s" : [ {
                     "value" : [ "/*\n@description: Given an interval, return the starting point if the interval has a starting boundary specified,\notherwise, return the ending point\n*/\n","define fluent function ","earliest","(","choice"," " ]
                  }, {
                     "r" : "979",
                     "s" : [ {
                        "value" : [ "Choice<" ]
                     }, {
                        "r" : "973",
                        "s" : [ {
                           "value" : [ "DateTime" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "974",
                        "s" : [ {
                           "value" : [ "Quantity" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "976",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "975",
                           "s" : [ {
                              "value" : [ "DateTime" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "978",
                        "s" : [ {
                           "value" : [ "Interval<" ]
                        }, {
                           "r" : "977",
                           "s" : [ {
                              "value" : [ "Quantity" ]
                           } ]
                        }, {
                           "value" : [ ">" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ " ):\n  " ]
                  }, {
                     "r" : "991",
                     "s" : [ {
                        "r" : "991",
                        "s" : [ {
                           "s" : [ {
                              "r" : "982",
                              "s" : [ {
                                 "r" : "981",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "981",
                                    "s" : [ {
                                       "r" : "980",
                                       "s" : [ {
                                          "value" : [ "choice" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "981",
                                       "s" : [ {
                                          "value" : [ "toInterval","()" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ " ","period" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n    " ]
                        }, {
                           "r" : "990",
                           "s" : [ {
                              "value" : [ "return\n      " ]
                           }, {
                              "r" : "989",
                              "s" : [ {
                                 "value" : [ "if " ]
                              }, {
                                 "r" : "984",
                                 "s" : [ {
                                    "value" : [ "(" ]
                                 }, {
                                    "r" : "984",
                                    "s" : [ {
                                       "r" : "983",
                                       "s" : [ {
                                          "value" : [ "period" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "984",
                                       "s" : [ {
                                          "value" : [ "hasStart","()" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ ")" ]
                                 } ]
                              }, {
                                 "value" : [ " then " ]
                              }, {
                                 "r" : "986",
                                 "s" : [ {
                                    "value" : [ "start of " ]
                                 }, {
                                    "r" : "985",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      else " ]
                              }, {
                                 "r" : "988",
                                 "s" : [ {
                                    "value" : [ "end of " ]
                                 }, {
                                    "r" : "987",
                                    "s" : [ {
                                       "value" : [ "period" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "991",
               "locator" : "500:3-503:24",
               "type" : "Query",
               "source" : [ {
                  "localId" : "982",
                  "locator" : "500:3-500:30",
                  "alias" : "period",
                  "expression" : {
                     "localId" : "981",
                     "locator" : "500:3-500:23",
                     "name" : "toInterval",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "980",
                        "locator" : "500:4-500:9",
                        "name" : "choice",
                        "type" : "OperandRef"
                     } ]
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "990",
                  "locator" : "501:5-503:24",
                  "expression" : {
                     "localId" : "989",
                     "locator" : "502:7-503:24",
                     "type" : "If",
                     "condition" : {
                        "localId" : "984",
                        "locator" : "502:10-502:28",
                        "name" : "hasStart",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "983",
                           "locator" : "502:11-502:16",
                           "name" : "period",
                           "type" : "AliasRef"
                        } ]
                     },
                     "then" : {
                        "localId" : "986",
                        "locator" : "502:35-502:49",
                        "type" : "Start",
                        "operand" : {
                           "localId" : "985",
                           "locator" : "502:44-502:49",
                           "name" : "period",
                           "type" : "AliasRef"
                        }
                     },
                     "else" : {
                        "localId" : "988",
                        "locator" : "503:12-503:24",
                        "type" : "End",
                        "operand" : {
                           "localId" : "987",
                           "locator" : "503:19-503:24",
                           "name" : "period",
                           "type" : "AliasRef"
                        }
                     }
                  }
               }
            },
            "operand" : [ {
               "name" : "choice",
               "operandTypeSpecifier" : {
                  "localId" : "979",
                  "locator" : "499:40-499:105",
                  "type" : "ChoiceTypeSpecifier",
                  "choice" : [ {
                     "localId" : "973",
                     "locator" : "499:47-499:54",
                     "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "974",
                     "locator" : "499:57-499:64",
                     "name" : "{http://hl7.org/fhir}Quantity",
                     "type" : "NamedTypeSpecifier"
                  }, {
                     "localId" : "976",
                     "locator" : "499:67-499:84",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "975",
                        "locator" : "499:76-499:83",
                        "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "NamedTypeSpecifier"
                     }
                  }, {
                     "localId" : "978",
                     "locator" : "499:87-499:104",
                     "type" : "IntervalTypeSpecifier",
                     "pointType" : {
                        "localId" : "977",
                        "locator" : "499:96-499:103",
                        "name" : "{http://hl7.org/fhir}Quantity",
                        "type" : "NamedTypeSpecifier"
                     }
                  } ]
               }
            } ]
         }, {
            "localId" : "1002",
            "locator" : "508:1-512:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns the most recent Condition"
               } ],
               "s" : {
                  "r" : "1002",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns the most recent Condition\n*/\n","define function ","MostRecent","(","conditions"," " ]
                  }, {
                     "r" : "994",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "993",
                        "s" : [ {
                           "value" : [ "USCore",".","Condition" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1001",
                     "s" : [ {
                        "r" : "1001",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1000",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "996",
                                 "s" : [ {
                                    "r" : "995",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "conditions" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","C" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "999",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "998",
                                 "s" : [ {
                                    "r" : "997",
                                    "s" : [ {
                                       "value" : [ "recordedDate" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1001",
               "locator" : "509:3-512:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1000",
                  "locator" : "510:5-511:26",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "996",
                     "locator" : "510:5-510:16",
                     "alias" : "C",
                     "expression" : {
                        "localId" : "995",
                        "locator" : "510:5-510:14",
                        "name" : "conditions",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "999",
                     "locator" : "511:7-511:26",
                     "by" : [ {
                        "localId" : "998",
                        "locator" : "511:15-511:26",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "997",
                           "locator" : "511:15-511:26",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "recordedDate",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "conditions",
               "operandTypeSpecifier" : {
                  "localId" : "994",
                  "locator" : "508:39-508:60",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "993",
                     "locator" : "508:44-508:59",
                     "name" : "{http://hl7.org/fhir}Condition",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1012",
            "locator" : "517:1-521:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Return the most recent Observation"
               } ],
               "s" : {
                  "r" : "1012",
                  "s" : [ {
                     "value" : [ "/*\n@description: Return the most recent Observation\n*/\n","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1004",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1003",
                        "s" : [ {
                           "value" : [ "Observation" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1011",
                     "s" : [ {
                        "r" : "1011",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1010",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1006",
                                 "s" : [ {
                                    "r" : "1005",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1009",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1008",
                                 "s" : [ {
                                    "r" : "1007",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1011",
               "locator" : "518:3-521:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1010",
                  "locator" : "519:5-520:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1006",
                     "locator" : "519:5-519:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1005",
                        "locator" : "519:5-519:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1009",
                     "locator" : "520:7-520:20",
                     "by" : [ {
                        "localId" : "1008",
                        "locator" : "520:15-520:20",
                        "direction" : "asc",
                        "path" : "issued",
                        "type" : "ByColumn"
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1004",
                  "locator" : "517:41-517:57",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1003",
                     "locator" : "517:46-517:56",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1022",
            "locator" : "523:1-527:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1022",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1014",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1013",
                        "s" : [ {
                           "value" : [ "\"SmokingStatusProfile\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1021",
                     "s" : [ {
                        "r" : "1021",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1020",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1016",
                                 "s" : [ {
                                    "r" : "1015",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1019",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1018",
                                 "s" : [ {
                                    "r" : "1017",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1021",
               "locator" : "524:3-527:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1020",
                  "locator" : "525:5-526:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1016",
                     "locator" : "525:5-525:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1015",
                        "locator" : "525:5-525:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1019",
                     "locator" : "526:7-526:20",
                     "by" : [ {
                        "localId" : "1018",
                        "locator" : "526:15-526:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1017",
                           "locator" : "526:15-526:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1014",
                  "locator" : "523:41-523:68",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1013",
                     "locator" : "523:46-523:67",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1032",
            "locator" : "529:1-533:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1032",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1024",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1023",
                        "s" : [ {
                           "value" : [ "\"PulseOximetryProfile\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1031",
                     "s" : [ {
                        "r" : "1031",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1030",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1026",
                                 "s" : [ {
                                    "r" : "1025",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1029",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1028",
                                 "s" : [ {
                                    "r" : "1027",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1031",
               "locator" : "530:3-533:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1030",
                  "locator" : "531:5-532:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1026",
                     "locator" : "531:5-531:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1025",
                        "locator" : "531:5-531:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1029",
                     "locator" : "532:7-532:20",
                     "by" : [ {
                        "localId" : "1028",
                        "locator" : "532:15-532:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1027",
                           "locator" : "532:15-532:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1024",
                  "locator" : "529:41-529:68",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1023",
                     "locator" : "529:46-529:67",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1042",
            "locator" : "535:1-539:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1042",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1034",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1033",
                        "s" : [ {
                           "value" : [ "\"PediatricWeightForHeightObservationProfile\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1041",
                     "s" : [ {
                        "r" : "1041",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1040",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1036",
                                 "s" : [ {
                                    "r" : "1035",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1039",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1038",
                                 "s" : [ {
                                    "r" : "1037",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1041",
               "locator" : "536:3-539:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1040",
                  "locator" : "537:5-538:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1036",
                     "locator" : "537:5-537:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1035",
                        "locator" : "537:5-537:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1039",
                     "locator" : "538:7-538:20",
                     "by" : [ {
                        "localId" : "1038",
                        "locator" : "538:15-538:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1037",
                           "locator" : "538:15-538:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1034",
                  "locator" : "535:41-535:90",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1033",
                     "locator" : "535:46-535:89",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1052",
            "locator" : "541:3-545:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1052",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1044",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1043",
                        "s" : [ {
                           "value" : [ "\"PediatricBMIforAgeObservationProfile\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1051",
                     "s" : [ {
                        "r" : "1051",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1050",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1046",
                                 "s" : [ {
                                    "r" : "1045",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1049",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1048",
                                 "s" : [ {
                                    "r" : "1047",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1051",
               "locator" : "542:3-545:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1050",
                  "locator" : "543:5-544:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1046",
                     "locator" : "543:5-543:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1045",
                        "locator" : "543:5-543:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1049",
                     "locator" : "544:7-544:20",
                     "by" : [ {
                        "localId" : "1048",
                        "locator" : "544:15-544:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1047",
                           "locator" : "544:15-544:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1044",
                  "locator" : "541:43-541:86",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1043",
                     "locator" : "541:48-541:85",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1062",
            "locator" : "547:1-551:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1062",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1054",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1053",
                        "s" : [ {
                           "value" : [ "\"LaboratoryResultObservationProfile\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1061",
                     "s" : [ {
                        "r" : "1061",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1060",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1056",
                                 "s" : [ {
                                    "r" : "1055",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1059",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1058",
                                 "s" : [ {
                                    "r" : "1057",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1061",
               "locator" : "548:3-551:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1060",
                  "locator" : "549:5-550:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1056",
                     "locator" : "549:5-549:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1055",
                        "locator" : "549:5-549:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1059",
                     "locator" : "550:7-550:20",
                     "by" : [ {
                        "localId" : "1058",
                        "locator" : "550:15-550:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1057",
                           "locator" : "550:15-550:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1054",
                  "locator" : "547:41-547:82",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1053",
                     "locator" : "547:46-547:81",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1072",
            "locator" : "553:1-557:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1072",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1064",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1063",
                        "s" : [ {
                           "value" : [ "\"observation-vitalspanel\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1071",
                     "s" : [ {
                        "r" : "1071",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1070",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1066",
                                 "s" : [ {
                                    "r" : "1065",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1069",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1068",
                                 "s" : [ {
                                    "r" : "1067",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1071",
               "locator" : "554:3-557:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1070",
                  "locator" : "555:5-556:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1066",
                     "locator" : "555:5-555:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1065",
                        "locator" : "555:5-555:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1069",
                     "locator" : "556:7-556:20",
                     "by" : [ {
                        "localId" : "1068",
                        "locator" : "556:15-556:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1067",
                           "locator" : "556:15-556:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1064",
                  "locator" : "553:41-553:71",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1063",
                     "locator" : "553:46-553:70",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1082",
            "locator" : "559:1-563:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1082",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1074",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1073",
                        "s" : [ {
                           "value" : [ "\"observation-resprate\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1081",
                     "s" : [ {
                        "r" : "1081",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1080",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1076",
                                 "s" : [ {
                                    "r" : "1075",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1079",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1078",
                                 "s" : [ {
                                    "r" : "1077",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1081",
               "locator" : "560:3-563:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1080",
                  "locator" : "561:5-562:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1076",
                     "locator" : "561:5-561:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1075",
                        "locator" : "561:5-561:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1079",
                     "locator" : "562:7-562:20",
                     "by" : [ {
                        "localId" : "1078",
                        "locator" : "562:15-562:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1077",
                           "locator" : "562:15-562:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1074",
                  "locator" : "559:41-559:68",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1073",
                     "locator" : "559:46-559:67",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1092",
            "locator" : "565:3-569:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1092",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1084",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1083",
                        "s" : [ {
                           "value" : [ "\"observation-heartrate\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1091",
                     "s" : [ {
                        "r" : "1091",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1090",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1086",
                                 "s" : [ {
                                    "r" : "1085",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1089",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1088",
                                 "s" : [ {
                                    "r" : "1087",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1091",
               "locator" : "566:3-569:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1090",
                  "locator" : "567:5-568:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1086",
                     "locator" : "567:5-567:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1085",
                        "locator" : "567:5-567:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1089",
                     "locator" : "568:7-568:20",
                     "by" : [ {
                        "localId" : "1088",
                        "locator" : "568:15-568:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1087",
                           "locator" : "568:15-568:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1084",
                  "locator" : "565:43-565:71",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1083",
                     "locator" : "565:48-565:70",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1102",
            "locator" : "571:3-575:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1102",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1094",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1093",
                        "s" : [ {
                           "value" : [ "\"observation-oxygensat\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1101",
                     "s" : [ {
                        "r" : "1101",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1100",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1096",
                                 "s" : [ {
                                    "r" : "1095",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1099",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1098",
                                 "s" : [ {
                                    "r" : "1097",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1101",
               "locator" : "572:3-575:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1100",
                  "locator" : "573:5-574:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1096",
                     "locator" : "573:5-573:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1095",
                        "locator" : "573:5-573:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1099",
                     "locator" : "574:7-574:20",
                     "by" : [ {
                        "localId" : "1098",
                        "locator" : "574:15-574:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1097",
                           "locator" : "574:15-574:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1094",
                  "locator" : "571:43-571:71",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1093",
                     "locator" : "571:48-571:70",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1112",
            "locator" : "577:3-581:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1112",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1104",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1103",
                        "s" : [ {
                           "value" : [ "\"observation-bodytemp\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1111",
                     "s" : [ {
                        "r" : "1111",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1110",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1106",
                                 "s" : [ {
                                    "r" : "1105",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1109",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1108",
                                 "s" : [ {
                                    "r" : "1107",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1111",
               "locator" : "578:3-581:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1110",
                  "locator" : "579:5-580:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1106",
                     "locator" : "579:5-579:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1105",
                        "locator" : "579:5-579:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1109",
                     "locator" : "580:7-580:20",
                     "by" : [ {
                        "localId" : "1108",
                        "locator" : "580:15-580:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1107",
                           "locator" : "580:15-580:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1104",
                  "locator" : "577:43-577:70",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1103",
                     "locator" : "577:48-577:69",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1122",
            "locator" : "583:3-587:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1122",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1114",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1113",
                        "s" : [ {
                           "value" : [ "\"observation-headcircum\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1121",
                     "s" : [ {
                        "r" : "1121",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1120",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1116",
                                 "s" : [ {
                                    "r" : "1115",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1119",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1118",
                                 "s" : [ {
                                    "r" : "1117",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1121",
               "locator" : "584:3-587:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1120",
                  "locator" : "585:5-586:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1116",
                     "locator" : "585:5-585:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1115",
                        "locator" : "585:5-585:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1119",
                     "locator" : "586:7-586:20",
                     "by" : [ {
                        "localId" : "1118",
                        "locator" : "586:15-586:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1117",
                           "locator" : "586:15-586:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1114",
                  "locator" : "583:43-583:72",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1113",
                     "locator" : "583:48-583:71",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1132",
            "locator" : "589:3-593:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1132",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1124",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1123",
                        "s" : [ {
                           "value" : [ "\"observation-bp\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1131",
                     "s" : [ {
                        "r" : "1131",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1130",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1126",
                                 "s" : [ {
                                    "r" : "1125",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1129",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1128",
                                 "s" : [ {
                                    "r" : "1127",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1131",
               "locator" : "590:3-593:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1130",
                  "locator" : "591:5-592:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1126",
                     "locator" : "591:5-591:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1125",
                        "locator" : "591:5-591:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1129",
                     "locator" : "592:7-592:20",
                     "by" : [ {
                        "localId" : "1128",
                        "locator" : "592:15-592:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1127",
                           "locator" : "592:15-592:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1124",
                  "locator" : "589:43-589:64",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1123",
                     "locator" : "589:48-589:63",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1142",
            "locator" : "595:1-599:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1142",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1134",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1133",
                        "s" : [ {
                           "value" : [ "\"observation-bmi\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1141",
                     "s" : [ {
                        "r" : "1141",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1140",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1136",
                                 "s" : [ {
                                    "r" : "1135",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1139",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1138",
                                 "s" : [ {
                                    "r" : "1137",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1141",
               "locator" : "596:3-599:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1140",
                  "locator" : "597:5-598:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1136",
                     "locator" : "597:5-597:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1135",
                        "locator" : "597:5-597:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1139",
                     "locator" : "598:7-598:20",
                     "by" : [ {
                        "localId" : "1138",
                        "locator" : "598:15-598:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1137",
                           "locator" : "598:15-598:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1134",
                  "locator" : "595:41-595:63",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1133",
                     "locator" : "595:46-595:62",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1152",
            "locator" : "601:1-605:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1152",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1144",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1143",
                        "s" : [ {
                           "value" : [ "\"observation-bodyheight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1151",
                     "s" : [ {
                        "r" : "1151",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1150",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1146",
                                 "s" : [ {
                                    "r" : "1145",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1149",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1148",
                                 "s" : [ {
                                    "r" : "1147",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1151",
               "locator" : "602:3-605:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1150",
                  "locator" : "603:5-604:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1146",
                     "locator" : "603:5-603:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1145",
                        "locator" : "603:5-603:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1149",
                     "locator" : "604:7-604:20",
                     "by" : [ {
                        "localId" : "1148",
                        "locator" : "604:15-604:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1147",
                           "locator" : "604:15-604:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1144",
                  "locator" : "601:41-601:70",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1143",
                     "locator" : "601:46-601:69",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1162",
            "locator" : "607:1-611:3",
            "name" : "MostRecent",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1162",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecent","(","observations"," " ]
                  }, {
                     "r" : "1154",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1153",
                        "s" : [ {
                           "value" : [ "\"observation-bodyweight\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1161",
                     "s" : [ {
                        "r" : "1161",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1160",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1156",
                                 "s" : [ {
                                    "r" : "1155",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "observations" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","O" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1159",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1158",
                                 "s" : [ {
                                    "r" : "1157",
                                    "s" : [ {
                                       "value" : [ "issued" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1161",
               "locator" : "608:3-611:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1160",
                  "locator" : "609:5-610:20",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1156",
                     "locator" : "609:5-609:18",
                     "alias" : "O",
                     "expression" : {
                        "localId" : "1155",
                        "locator" : "609:5-609:16",
                        "name" : "observations",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1159",
                     "locator" : "610:7-610:20",
                     "by" : [ {
                        "localId" : "1158",
                        "locator" : "610:15-610:20",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1157",
                           "locator" : "610:15-610:20",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "observations",
               "operandTypeSpecifier" : {
                  "localId" : "1154",
                  "locator" : "607:41-607:70",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1153",
                     "locator" : "607:46-607:69",
                     "name" : "{http://hl7.org/fhir}Observation",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1172",
            "locator" : "613:1-617:3",
            "name" : "MostRecentMR",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1172",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecentMR","(","medicationRequests"," " ]
                  }, {
                     "r" : "1164",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1163",
                        "s" : [ {
                           "value" : [ "\"MedicationRequestProfile\"" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1171",
                     "s" : [ {
                        "r" : "1171",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1170",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1166",
                                 "s" : [ {
                                    "r" : "1165",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "medicationRequests" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","MR" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1169",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1168",
                                 "s" : [ {
                                    "r" : "1167",
                                    "s" : [ {
                                       "value" : [ "authoredOn" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1171",
               "locator" : "614:3-617:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1170",
                  "locator" : "615:5-616:24",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1166",
                     "locator" : "615:5-615:25",
                     "alias" : "MR",
                     "expression" : {
                        "localId" : "1165",
                        "locator" : "615:5-615:22",
                        "name" : "medicationRequests",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1169",
                     "locator" : "616:7-616:24",
                     "by" : [ {
                        "localId" : "1168",
                        "locator" : "616:15-616:24",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1167",
                           "locator" : "616:15-616:24",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "authoredOn",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "medicationRequests",
               "operandTypeSpecifier" : {
                  "localId" : "1164",
                  "locator" : "613:49-613:80",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1163",
                     "locator" : "613:54-613:79",
                     "name" : "{http://hl7.org/fhir}MedicationRequest",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1186",
            "locator" : "619:1-623:3",
            "name" : "MostRecentSR",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1186",
                  "s" : [ {
                     "value" : [ "","define function ","MostRecentSR","(","serviceRequests"," " ]
                  }, {
                     "r" : "1174",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1173",
                        "s" : [ {
                           "value" : [ "FHIR",".","ServiceRequest" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1185",
                     "s" : [ {
                        "r" : "1185",
                        "s" : [ {
                           "value" : [ "Last","(\n    " ]
                        }, {
                           "r" : "1184",
                           "s" : [ {
                              "s" : [ {
                                 "r" : "1176",
                                 "s" : [ {
                                    "r" : "1175",
                                    "s" : [ {
                                       "s" : [ {
                                          "value" : [ "serviceRequests" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","SR" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      " ]
                           }, {
                              "r" : "1183",
                              "s" : [ {
                                 "value" : [ "sort by " ]
                              }, {
                                 "r" : "1182",
                                 "s" : [ {
                                    "r" : "1181",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "1181",
                                       "s" : [ {
                                          "r" : "1179",
                                          "s" : [ {
                                             "r" : "1177",
                                             "s" : [ {
                                                "value" : [ "FHIRHelpers" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "1179",
                                             "s" : [ {
                                                "value" : [ "ToDateTime","(" ]
                                             }, {
                                                "r" : "1178",
                                                "s" : [ {
                                                   "value" : [ "authoredOn" ]
                                                } ]
                                             }, {
                                                "value" : [ ")" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " as " ]
                                       }, {
                                          "r" : "1180",
                                          "s" : [ {
                                             "value" : [ "DateTime" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n  )" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1185",
               "locator" : "620:3-623:3",
               "type" : "Last",
               "source" : {
                  "localId" : "1184",
                  "locator" : "621:5-622:62",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1176",
                     "locator" : "621:5-621:22",
                     "alias" : "SR",
                     "expression" : {
                        "localId" : "1175",
                        "locator" : "621:5-621:19",
                        "name" : "serviceRequests",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "sort" : {
                     "localId" : "1183",
                     "locator" : "622:7-622:62",
                     "by" : [ {
                        "localId" : "1182",
                        "locator" : "622:15-622:62",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "1181",
                           "locator" : "622:15-622:62",
                           "strict" : false,
                           "type" : "As",
                           "operand" : {
                              "localId" : "1179",
                              "locator" : "622:16-622:49",
                              "name" : "ToDateTime",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "localId" : "1178",
                                 "locator" : "622:39-622:48",
                                 "name" : "authoredOn",
                                 "type" : "IdentifierRef"
                              } ]
                           },
                           "asTypeSpecifier" : {
                              "localId" : "1180",
                              "locator" : "622:54-622:61",
                              "name" : "{urn:hl7-org:elm-types:r1}DateTime",
                              "type" : "NamedTypeSpecifier"
                           }
                        }
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "serviceRequests",
               "operandTypeSpecifier" : {
                  "localId" : "1174",
                  "locator" : "619:46-619:70",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1173",
                     "locator" : "619:51-619:69",
                     "name" : "{http://hl7.org/fhir}ServiceRequest",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         }, {
            "localId" : "1197",
            "locator" : "626:1-627:57",
            "name" : "Mobile",
            "context" : "Patient",
            "accessLevel" : "Public",
            "type" : "FunctionDef",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1197",
                  "s" : [ {
                     "value" : [ "","define function ","Mobile","(","contactPoints"," " ]
                  }, {
                     "r" : "1188",
                     "s" : [ {
                        "value" : [ "List<" ]
                     }, {
                        "r" : "1187",
                        "s" : [ {
                           "value" : [ "USCore",".","ContactPoint" ]
                        } ]
                     }, {
                        "value" : [ ">" ]
                     } ]
                  }, {
                     "value" : [ "):\n  " ]
                  }, {
                     "r" : "1196",
                     "s" : [ {
                        "r" : "1196",
                        "s" : [ {
                           "value" : [ "singleton from " ]
                        }, {
                           "r" : "1195",
                           "s" : [ {
                              "value" : [ "(" ]
                           }, {
                              "r" : "1195",
                              "s" : [ {
                                 "s" : [ {
                                    "r" : "1190",
                                    "s" : [ {
                                       "r" : "1189",
                                       "s" : [ {
                                          "s" : [ {
                                             "value" : [ "contactPoints" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","P" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " " ]
                              }, {
                                 "r" : "1194",
                                 "s" : [ {
                                    "value" : [ "where " ]
                                 }, {
                                    "r" : "1194",
                                    "s" : [ {
                                       "r" : "1192",
                                       "s" : [ {
                                          "r" : "1191",
                                          "s" : [ {
                                             "value" : [ "P" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "1192",
                                          "s" : [ {
                                             "value" : [ "use" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ " ","="," " ]
                                    }, {
                                       "r" : "1193",
                                       "s" : [ {
                                          "value" : [ "'mobile'" ]
                                       } ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ ")" ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "1196",
               "locator" : "627:3-627:57",
               "type" : "SingletonFrom",
               "operand" : {
                  "localId" : "1195",
                  "locator" : "627:18-627:57",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "1190",
                     "locator" : "627:19-627:33",
                     "alias" : "P",
                     "expression" : {
                        "localId" : "1189",
                        "locator" : "627:19-627:31",
                        "name" : "contactPoints",
                        "type" : "OperandRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "1194",
                     "locator" : "627:35-627:56",
                     "type" : "Equal",
                     "operand" : [ {
                        "localId" : "1192",
                        "locator" : "627:41-627:45",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "use",
                           "scope" : "P",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "1193",
                        "locator" : "627:49-627:56",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "mobile",
                        "type" : "Literal"
                     } ]
                  }
               }
            },
            "operand" : [ {
               "name" : "contactPoints",
               "operandTypeSpecifier" : {
                  "localId" : "1188",
                  "locator" : "626:38-626:62",
                  "type" : "ListTypeSpecifier",
                  "elementType" : {
                     "localId" : "1187",
                     "locator" : "626:43-626:61",
                     "name" : "{http://hl7.org/fhir}ContactPoint",
                     "type" : "NamedTypeSpecifier"
                  }
               }
            } ]
         } ]
      }
   }
}" + } ] +} \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreElements.json b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreElements.json new file mode 100644 index 000000000..f80bdb857 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreElements.json @@ -0,0 +1,542 @@ +{ + "resourceType": "Library", + "id": "USCoreElements", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/cqf/us/common/Library/USCoreElements", + "version": "0.1.0", + "name": "USCoreElements", + "relatedArtifact": [ { + "type": "depends-on", + "display": "USCore model information", + "resource": "http://hl7.org/fhir/Library/USCore-ModelInfo" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Library UC", + "resource": "http://fhir.org/guides/cqf/us/common/Library/USCoreCommon|0.1.0" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Code system SNOMEDCT", + "resource": "http://snomed.info/sct" + }, { + "type": "depends-on", + "display": "Code system AllergyIntoleranceVerificationStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-verification" + }, { + "type": "depends-on", + "display": "Code system AllergyIntoleranceClinicalStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical" + }, { + "type": "depends-on", + "display": "Code system ConditionCategory", + "resource": "http://terminology.hl7.org/CodeSystem/condition-category" + }, { + "type": "depends-on", + "display": "Code system ConditionVerificationStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/condition-ver-status" + }, { + "type": "depends-on", + "display": "Code system ConditionClinicalStatusCodes", + "resource": "http://terminology.hl7.org/CodeSystem/condition-clinical" + }, { + "type": "depends-on", + "display": "Code system USCoreConditionCategory", + "resource": "http://hl7.org/fhir/us/core/CodeSystem/condition-category" + }, { + "type": "depends-on", + "display": "Value set Common allergy substances", + "resource": "http://hl7.org/fhir/us/core/ValueSet/us-core-allergy-substance" + } ], + "parameter": [ { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Usual Name", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Official Name", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "First Occurrence of Non-Official, Non-Usual Name", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Name", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Last Name", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Name - First Middle(s) Last", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "Name - Last, First Middle(s)", + "use": "out", + "min": 0, + "max": "1", + "type": "string" + }, { + "name": "All Allergies and Intolerances", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Active Confirmed Allergies and Intolerances", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Common Allergies and Intolerances", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Active Confirmed Common Allergies and Intolerances", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "No Known Allergies (Not Asked)", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "No Known Allergies (Confirmed)", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Conditions", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Problem List Items", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Active Confirmed Problem List Items", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Encounter Diagnoses", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Health Concerns", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Diagnostic Reports for Laboratory Results", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Diagnostic Report Notes", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Encounters", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Performed Encounters", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Immunizations", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Completed Immunizations", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Implantable Devices", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Laboratory Results", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Resulted Laboratory Results", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Medication Requests", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Most Recent Medication Request", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "Active Medication Orders", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Medications", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Pediatric BMI for Age", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Pediatric Weight for Height", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Procedures", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Performed Procedures", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Pulse Oximetry", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Smoking Status", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Most Recent Smoking Status", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "All Vital Signs Panels", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Respiratory Rate Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Heart Rate Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Oxygen Saturation Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Body Temperature Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Body Height Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Head Circumference Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Body Weight Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Body Mass Index Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "All Blood Pressure Measurements", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Systolic Blood Pressure", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "Diastolic Blood Pressure", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + } ], + "dataRequirement": [ { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "use", "use.value" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ], + "mustSupport": [ "code" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ], + "mustSupport": [ "code" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ], + "mustSupport": [ "code" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ] + }, { + "type": "DiagnosticReport", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab" ] + }, { + "type": "DiagnosticReport", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note" ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" ], + "mustSupport": [ "status", "status.value" ] + }, { + "type": "Immunization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization" ] + }, { + "type": "Immunization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization" ], + "mustSupport": [ "status", "status.value" ] + }, { + "type": "Device", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab" ], + "mustSupport": [ "status", "status.value" ] + }, { + "type": "MedicationRequest", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest" ] + }, { + "type": "MedicationRequest", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest" ], + "mustSupport": [ "status", "status.value", "intent", "intent.value" ] + }, { + "type": "Medication", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height" ] + }, { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" ], + "mustSupport": [ "status", "status.value" ] + }, { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" ], + "mustSupport": [ "status", "status.value" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus" ], + "mustSupport": [ "status", "status.value" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/vitalspanel" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/resprate" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/heartrate" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/oxygensat" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodytemp" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyheight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/headcircum" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyweight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bmi" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ], + "mustSupport": [ "component", "value" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ], + "mustSupport": [ "component", "value" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ], + "mustSupport": [ "component", "value" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ], + "mustSupport": [ "component", "value" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ], + "mustSupport": [ "code" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "library USCoreElements version '0.1.0'

using USCore version '3.1.1'

include FHIRHelpers version '4.1.000'
include USCoreCommon version '0.1.0' called UC

valueset "Common allergy substances": 'http://hl7.org/fhir/us/core/ValueSet/us-core-allergy-substance'

code "No known allergy (situation)": '716186003' from UC.SNOMEDCT

context Patient

define "Usual Name":
  First(
    Patient.name name
      where name.use ~ 'usual'
  )

define "Official Name":
  First(
    Patient.name name
      where name.use ~ 'official'
  )

define "First Occurrence of Non-Official, Non-Usual Name":
  First(
    Patient.name name
      where not(name.use ~ 'official') and not(name.use ~ 'usual')
  )

define "Name":
  Coalesce("Official Name", "Usual Name", "First Occurrence of Non-Official, Non-Usual Name")

// TODO: Correct this once USCore.HumanName.given works as expected
// define "First Name":
//   "Name".given[0]

// TODO: Correct this once USCore.HumanName.given works as expected
// define "Middle Names":
//   Combine(Skip("Name".given, 1), ' ')

define "Last Name":
  "Name".family

// TODO: Correct this once USCore.HumanName.given works as expected
define "Name - First Middle(s) Last":
  //Combine("Name".given, ' ') + ' ' + "Name".family
  "Name".family

// TODO: Correct this once USCore.HumanName.given works as expected
define "Name - Last, First Middle(s)":
  //"Name".family + ', ' + Combine("Name".given, ' ')
  "Name".family

// Allergy/Intolerance

/*
@description: Returns all allergies and intolerances
@comment: This definition returns all allergies and intolerances conforming to the US Core 3.1.1
[AllergyIntolerance](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-allergyintolerance.html) profile.
Allergies and intolerances returned by this definition include records with any clinical status (including none)
and any verification status (including none).
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance
*/
define "All Allergies and Intolerances":
  ["AllergyIntolerance"]

define "Active Confirmed Allergies and Intolerances":
  "All Allergies and Intolerances".allergyActive().allergyConfirmed()

define "Common Allergies and Intolerances":
  "All Allergies and Intolerances" A
    where A.code in "Common allergy substances"

define "Active Confirmed Common Allergies and Intolerances":
  "Common Allergies and Intolerances".allergyActive().allergyConfirmed()

// No Known Allergies (Not Asked)
define "No Known Allergies (Not Asked)":
  "All Allergies and Intolerances" A
    where A.code ~ "No known allergy (situation)"
      and A.isAllergyActive()
      and A.isAllergyUnconfirmed()

// No Known Allergies (Confirmed)
define "No Known Allergies (Confirmed)":
  "All Allergies and Intolerances" A
    where A.code ~ "No known allergy (situation)"
      and A.isAllergyActive()
      and A.isAllergyConfirmed()

// Condition

/*
@description: Returns all problem list items, encounter diagnoses, and health concerns
@comment: This definition returns all conditions of any category conforming to the US Core 3.1.1
[Condition](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-condition.html) profile.
Conditions returned by this definition include records with any clinical status (including none) and
any verification status (including none).
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition
*/
define "All Conditions":
  ["Condition"]

define "All Problem List Items":
  "All Conditions" C
    where C.isProblemListItem()

define "Active Confirmed Problem List Items":
  "All Problem List Items".active().confirmed()

define "All Encounter Diagnoses":
  "All Conditions" C
    where C.isEncounterDiagnosis()

define "All Health Concerns":
  "All Conditions" C
    where C.isHealthConcern()

// Laboratory Diagnostic Report

/*
@comment: [Diagnostic Report for Laboratory Results](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-lab.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab
*/
define "All Diagnostic Reports for Laboratory Results":
  ["DiagnosticReportProfileLaboratoryReporting"]

// Diagnostic Report

/*
@comment: [Diagnostic Report Note](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-note.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note
*/
define "All Diagnostic Report Notes":
  ["DiagnosticReportProfileNoteExchange"]

// Encounter

/*
@comment: [Encounter](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-encounter.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter 
*/
define "All Encounters":
  ["EncounterProfile"]

define "All Performed Encounters":
  "All Encounters" E
    where E.status = 'finished'  

// Immunization

/*
@comment: [Immunization](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-immunization.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization
*/
define "All Immunizations":
  ["ImmunizationProfile"] 

define "All Completed Immunizations":
  "All Immunizations" I
    where I.status = 'completed'

// Implantable Device

/*
@comment: [Implantable Device](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-implantable-device.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device
*/
define "All Implantable Devices":
  ["ImplantableDeviceProfile"]

// Laboratory Result

/*
@description: Returns all laboratory results
@comment: [Laboratory Result](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-observation-lab.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab
*/
define "All Laboratory Results":
  ["LaboratoryResultObservationProfile"]

define "Resulted Laboratory Results":
  "All Laboratory Results" L
    where L.status in { 'preliminary', 'final', 'amended', 'corrected' }

// Medication Request

/*
@description: Returns all medication requests
@comment: [Medication Request](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medicationrequest.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest
*/
define "Most Recent Medication Request":
  UC.MostRecentMR("All Medication Requests")

define "All Medication Requests":
  ["MedicationRequestProfile"]

define "Active Medication Orders":
  "All Medication Requests" M
    where M.status = 'active'
      and M.intent in { 'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order' }

define "All Medications":
  ["MedicationProfile"]

// Pediatric BMI for Age

/*
@comment: [Pediatric BMI for Age](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-bmi-for-age.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age
*/
define "Pediatric BMI for Age":
  ["PediatricBMIforAgeObservationProfile"]

// Pediatric Head Circumference Percentile

/*
@comment: [Pediatric Head Circumference Percentile](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-head-occipital-frontal-circumference-percentile.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/head-occipital-frontal-circumference-percentile
*/
//define "All Pediatric Head Circumference Percentile Measurements":
  //TODO - profile not in modelinfo
  //UsCorePediatricHeadOccipitalFrontalCircumferencePercentileProfile


// Pediatric Weight for Height

/*
@comment: [Pediatric Weight for Height](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-weight-for-height.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height
*/
define "Pediatric Weight for Height":
  ["PediatricWeightForHeightObservationProfile"]

// Procedure

/*
@comment: [Procedure](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-procedure.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure
*/
define "All Procedures":
  ["ProcedureProfile"] P
    where P.status in { 'preparation', 'in-progress', 'on-hold', 'completed' }

define "All Performed Procedures":
  "All Procedures" P
    where P.status = 'completed'

// Pulse Oximetry

/*
@comment: [Pulse Oximetry](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-pulse-oximetry.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry
*/
define "Pulse Oximetry":
  ["PulseOximetryProfile"]

// Smoking Status

/*
@description: Returns all smoking status observations
@comment: This definition returns all smoking status observations conforming to the US Core 3.1.1
[Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)
profile.
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus
*/
define "Smoking Status":
  ["SmokingStatusProfile"]

/*
@description: Returns the most recent smoking status
@comment: This definition returns the most recent (by issued time) smoking status observation conforming to the
US Core 3.1.1 [Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)
profile.
*/
define "Most Recent Smoking Status":
  Last(
    "Smoking Status" SS
        where SS.status = 'final'
        sort by issued
  )

// Vital Signs Panel

/*
@comment: [Vital Signs Panel](http://hl7.org/fhir/R4/vitalspanel.html)
@profile: http://hl7.org/fhir/StructureDefinition/vitalspanel
*/
define "All Vital Signs Panels":
  ["observation-vitalspanel"]

// Respiratory Rate

/*
@comment: [Respiratory Rate](http://hl7.org/fhir/R4/resprate.html)
@profile: http://hl7.org/fhir/StructureDefinition/resprate
*/
define "All Respiratory Rate Measurements":
  ["observation-resprate"]

// Heart Rate

/*
@comment: [Heart Rate](http://hl7.org/fhir/R4/heartrate.html)
@profile:http://hl7.org/fhir/StructureDefinition/heartrate
*/
define "All Heart Rate Measurements":
  ["observation-heartrate"]

// Oxygen Saturation

/*
@comment: [Oxygen Saturation](http://hl7.org/fhir/R4/oxygensat.html)
@profile: http://hl7.org/fhir/StructureDefinition/oxygensat
*/
define "All Oxygen Saturation Measurements":
  ["observation-oxygensat"]

// Body Temperature

/*
@comment: [Body Temperature](http://hl7.org/fhir/R4/bodytemp.html)
@profile: http://hl7.org/fhir/StructureDefinition/bodytemp
*/
define "All Body Temperature Measurements":
  ["observation-bodytemp"]

// Body Height

/*
@comment: [Body Height](http://hl7.org/fhir/R4/bodyheight.html)
@profile: http://hl7.org/fhir/StructureDefinition/bodyheight
*/
define "All Body Height Measurements":
  ["observation-bodyheight"]

// Head Circumference

/*
@comment: [Head Circumference](http://hl7.org/fhir/R4/headcircum.html)
@profile: http://hl7.org/fhir/StructureDefinition/headcircum
*/
define "All Head Circumference Measurements":
  ["observation-headcircum"]

// Body Weight

/*
@comment: [Body Weight](http://hl7.org/fhir/R4/bodyweight.html)
@profile: http://hl7.org/fhir/StructureDefinition/bodyweight
*/
define "All Body Weight Measurements":
  ["observation-bodyweight"]

// Body Mass Index

/*
@comment: [Body Mass Index](http://hl7.org/fhir/R4/bmi.html)
@profile: http://hl7.org/fhir/StructureDefinition/bmi
*/
define "All Body Mass Index Measurements":
  ["observation-bmi"]

// Blood Pressure

/*
@comment: [Blood Pressure](http://hl7.org/fhir/R4/bp.html)
@profile: http://hl7.org/fhir/StructureDefinition/bp
*/
define "All Blood Pressure Measurements":
  ["observation-bp"]

// Systolic Blood Pressure
define "Systolic Blood Pressure":
  "All Blood Pressure Measurements".SystolicBP.value
  
// Diastolic Blood Pressure
define "Diastolic Blood Pressure":
  "All Blood Pressure Measurements".DiastolicBP.value


" + }, { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1">
   <annotation translatorVersion="2.7.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:s r="258">
         <a:s>library USCoreElements version '0.1.0'</a:s>
      </a:s>
   </annotation>
   <identifier id="USCoreElements" system="http://fhir.org/guides/cqf/us/common" version="0.1.0"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="3:1-3:28" localIdentifier="USCore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="1">
               <a:s>using </a:s>
               <a:s>
                  <a:s>USCore</a:s>
               </a:s>
               <a:s> version '3.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="2" locator="5:1-5:37" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/cqf/us/common/FHIRHelpers" version="4.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="2">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.1.000'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="3" locator="6:1-6:46" localIdentifier="UC" path="http://fhir.org/guides/cqf/us/common/USCoreCommon" version="0.1.0">
         <annotation xsi:type="a:Annotation">
            <a:s r="3">
               <a:s>include </a:s>
               <a:s>
                  <a:s>USCoreCommon</a:s>
               </a:s>
               <a:s> version '0.1.0' called UC</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <valueSets>
      <def localId="4" locator="8:1-8:102" name="Common allergy substances" id="http://hl7.org/fhir/us/core/ValueSet/us-core-allergy-substance" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="4">
               <a:s>valueset &quot;Common allergy substances&quot;: 'http://hl7.org/fhir/us/core/ValueSet/us-core-allergy-substance'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <codes>
      <def localId="6" locator="10:1-10:65" name="No known allergy (situation)" id="716186003" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="6">
               <a:s>code &quot;No known allergy (situation)&quot;: '716186003' from </a:s>
               <a:s r="5">
                  <a:s>UC.SNOMEDCT</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="5" locator="10:55-10:65" name="SNOMEDCT" libraryName="UC"/>
      </def>
   </codes>
   <contexts>
      <def locator="12:1-12:15" name="Patient"/>
   </contexts>
   <statements>
      <def locator="12:1-12:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="12:1-12:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="15" locator="14:1-18:3" name="Usual Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="15">
               <a:s>define &quot;Usual Name&quot;:
  </a:s>
               <a:s r="14">
                  <a:s>First(
    </a:s>
                  <a:s r="13">
                     <a:s>
                        <a:s r="8">
                           <a:s r="7">
                              <a:s>
                                 <a:s>Patient.name</a:s>
                              </a:s>
                           </a:s>
                           <a:s> name</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
      </a:s>
                     <a:s r="12">
                        <a:s>where </a:s>
                        <a:s r="12">
                           <a:s r="10">
                              <a:s r="9">
                                 <a:s>name</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="10">
                                 <a:s>use</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="11">
                              <a:s>'usual'</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  )</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="14" locator="15:3-18:3" xsi:type="First">
            <source localId="13" locator="16:5-17:30" xsi:type="Query">
               <source localId="8" locator="16:5-16:21" alias="name">
                  <expression localId="7" locator="16:5-16:16" path="name" xsi:type="Property">
                     <source name="Patient" xsi:type="ExpressionRef"/>
                  </expression>
               </source>
               <where localId="12" locator="17:7-17:30" xsi:type="Equivalent">
                  <operand localId="10" locator="17:13-17:20" path="value" xsi:type="Property">
                     <source path="use" scope="name" xsi:type="Property"/>
                  </operand>
                  <operand localId="11" locator="17:24-17:30" valueType="t:String" value="usual" xsi:type="Literal"/>
               </where>
            </source>
         </expression>
      </def>
      <def localId="24" locator="20:1-24:3" name="Official Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="24">
               <a:s>define &quot;Official Name&quot;:
  </a:s>
               <a:s r="23">
                  <a:s>First(
    </a:s>
                  <a:s r="22">
                     <a:s>
                        <a:s r="17">
                           <a:s r="16">
                              <a:s>
                                 <a:s>Patient.name</a:s>
                              </a:s>
                           </a:s>
                           <a:s> name</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
      </a:s>
                     <a:s r="21">
                        <a:s>where </a:s>
                        <a:s r="21">
                           <a:s r="19">
                              <a:s r="18">
                                 <a:s>name</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="19">
                                 <a:s>use</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="20">
                              <a:s>'official'</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  )</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="23" locator="21:3-24:3" xsi:type="First">
            <source localId="22" locator="22:5-23:33" xsi:type="Query">
               <source localId="17" locator="22:5-22:21" alias="name">
                  <expression localId="16" locator="22:5-22:16" path="name" xsi:type="Property">
                     <source name="Patient" xsi:type="ExpressionRef"/>
                  </expression>
               </source>
               <where localId="21" locator="23:7-23:33" xsi:type="Equivalent">
                  <operand localId="19" locator="23:13-23:20" path="value" xsi:type="Property">
                     <source path="use" scope="name" xsi:type="Property"/>
                  </operand>
                  <operand localId="20" locator="23:24-23:33" valueType="t:String" value="official" xsi:type="Literal"/>
               </where>
            </source>
         </expression>
      </def>
      <def localId="40" locator="26:1-30:3" name="First Occurrence of Non-Official, Non-Usual Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="40">
               <a:s>define &quot;First Occurrence of Non-Official, Non-Usual Name&quot;:
  </a:s>
               <a:s r="39">
                  <a:s>First(
    </a:s>
                  <a:s r="38">
                     <a:s>
                        <a:s r="26">
                           <a:s r="25">
                              <a:s>
                                 <a:s>Patient.name</a:s>
                              </a:s>
                           </a:s>
                           <a:s> name</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
      </a:s>
                     <a:s r="37">
                        <a:s>where </a:s>
                        <a:s r="37">
                           <a:s r="31">
                              <a:s>not</a:s>
                              <a:s r="30">
                                 <a:s>(</a:s>
                                 <a:s r="30">
                                    <a:s r="28">
                                       <a:s r="27">
                                          <a:s>name</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="28">
                                          <a:s>use</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> ~ </a:s>
                                    <a:s r="29">
                                       <a:s>'official'</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                           <a:s> and </a:s>
                           <a:s r="36">
                              <a:s>not</a:s>
                              <a:s r="35">
                                 <a:s>(</a:s>
                                 <a:s r="35">
                                    <a:s r="33">
                                       <a:s r="32">
                                          <a:s>name</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="33">
                                          <a:s>use</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> ~ </a:s>
                                    <a:s r="34">
                                       <a:s>'usual'</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>)</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  )</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="39" locator="27:3-30:3" xsi:type="First">
            <source localId="38" locator="28:5-29:66" xsi:type="Query">
               <source localId="26" locator="28:5-28:21" alias="name">
                  <expression localId="25" locator="28:5-28:16" path="name" xsi:type="Property">
                     <source name="Patient" xsi:type="ExpressionRef"/>
                  </expression>
               </source>
               <where localId="37" locator="29:7-29:66" xsi:type="And">
                  <operand localId="31" locator="29:13-29:38" xsi:type="Not">
                     <operand localId="30" locator="29:16-29:38" xsi:type="Equivalent">
                        <operand localId="28" locator="29:17-29:24" path="value" xsi:type="Property">
                           <source path="use" scope="name" xsi:type="Property"/>
                        </operand>
                        <operand localId="29" locator="29:28-29:37" valueType="t:String" value="official" xsi:type="Literal"/>
                     </operand>
                  </operand>
                  <operand localId="36" locator="29:44-29:66" xsi:type="Not">
                     <operand localId="35" locator="29:47-29:66" xsi:type="Equivalent">
                        <operand localId="33" locator="29:48-29:55" path="value" xsi:type="Property">
                           <source path="use" scope="name" xsi:type="Property"/>
                        </operand>
                        <operand localId="34" locator="29:59-29:65" valueType="t:String" value="usual" xsi:type="Literal"/>
                     </operand>
                  </operand>
               </where>
            </source>
         </expression>
      </def>
      <def localId="45" locator="32:1-33:93" name="Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="45">
               <a:s>define &quot;Name&quot;:
  </a:s>
               <a:s r="44">
                  <a:s>Coalesce(</a:s>
                  <a:s r="41">
                     <a:s>&quot;Official Name&quot;</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="42">
                     <a:s>&quot;Usual Name&quot;</a:s>
                  </a:s>
                  <a:s>, </a:s>
                  <a:s r="43">
                     <a:s>&quot;First Occurrence of Non-Official, Non-Usual Name&quot;</a:s>
                  </a:s>
                  <a:s>)</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="44" locator="33:3-33:93" xsi:type="Coalesce">
            <operand localId="41" locator="33:12-33:26" name="Official Name" xsi:type="ExpressionRef"/>
            <operand localId="42" locator="33:29-33:40" name="Usual Name" xsi:type="ExpressionRef"/>
            <operand localId="43" locator="33:43-33:92" name="First Occurrence of Non-Official, Non-Usual Name" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="48" locator="43:1-44:15" name="Last Name" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="48">
               <a:s>// TODO: Correct this once USCore.HumanName.given works as expected
// define &quot;First Name&quot;:
//   &quot;Name&quot;.given[0]

// TODO: Correct this once USCore.HumanName.given works as expected
// define &quot;Middle Names&quot;:
//   Combine(Skip(&quot;Name&quot;.given, 1), ' ')
define &quot;Last Name&quot;:
  </a:s>
               <a:s r="47">
                  <a:s r="46">
                     <a:s>&quot;Name&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="47">
                     <a:s>family</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="47" locator="44:3-44:15" path="value" xsi:type="Property">
            <source path="family" xsi:type="Property">
               <source localId="46" locator="44:3-44:8" name="Name" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="51" locator="47:1-49:15" name="Name - First Middle(s) Last" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="51">
               <a:s>// TODO: Correct this once USCore.HumanName.given works as expected
define &quot;Name - First Middle(s) Last&quot;:
  //Combine(&quot;Name&quot;.given, ' ') + ' ' + &quot;Name&quot;.family
  </a:s>
               <a:s r="50">
                  <a:s r="49">
                     <a:s>&quot;Name&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="50">
                     <a:s>family</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="50" locator="49:3-49:15" path="value" xsi:type="Property">
            <source path="family" xsi:type="Property">
               <source localId="49" locator="49:3-49:8" name="Name" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="54" locator="52:1-54:15" name="Name - Last, First Middle(s)" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="54">
               <a:s>// TODO: Correct this once USCore.HumanName.given works as expected
define &quot;Name - Last, First Middle(s)&quot;:
  //&quot;Name&quot;.family + ', ' + Combine(&quot;Name&quot;.given, ' ')
  </a:s>
               <a:s r="53">
                  <a:s r="52">
                     <a:s>&quot;Name&quot;</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="53">
                     <a:s>family</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="53" locator="54:3-54:15" path="value" xsi:type="Property">
            <source path="family" xsi:type="Property">
               <source localId="52" locator="54:3-54:8" name="Name" xsi:type="ExpressionRef"/>
            </source>
         </expression>
      </def>
      <def localId="56" locator="66:1-67:24" name="All Allergies and Intolerances" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns all allergies and intolerances"/>
            <a:t name="comment" value="This definition returns all allergies and intolerances conforming to the US Core 3.1.1&#xa;[AllergyIntolerance](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-allergyintolerance.html) profile.&#xa;Allergies and intolerances returned by this definition include records with any clinical status (including none)&#xa;and any verification status (including none)."/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance"/>
            <a:s r="56">
               <a:s>// Allergy/Intolerance

/*
@description: Returns all allergies and intolerances
@comment: This definition returns all allergies and intolerances conforming to the US Core 3.1.1
[AllergyIntolerance](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-allergyintolerance.html) profile.
Allergies and intolerances returned by this definition include records with any clinical status (including none)
and any verification status (including none).
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance
*/
define &quot;All Allergies and Intolerances&quot;:
  </a:s>
               <a:s r="55">
                  <a:s>[&quot;AllergyIntolerance&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="55" locator="67:3-67:24" dataType="fhir:AllergyIntolerance" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" xsi:type="Retrieve"/>
      </def>
      <def localId="60" locator="69:1-70:69" name="Active Confirmed Allergies and Intolerances" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="60">
               <a:s>define &quot;Active Confirmed Allergies and Intolerances&quot;:
  </a:s>
               <a:s r="59">
                  <a:s r="58">
                     <a:s r="57">
                        <a:s>&quot;All Allergies and Intolerances&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="58">
                        <a:s>allergyActive()</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="59">
                     <a:s>allergyConfirmed()</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="59" locator="70:3-70:69" name="allergyConfirmed" libraryName="UC" xsi:type="FunctionRef">
            <operand localId="58" locator="70:3-70:50" name="allergyActive" libraryName="UC" xsi:type="FunctionRef">
               <operand localId="57" locator="70:3-70:34" name="All Allergies and Intolerances" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="68" locator="72:1-74:47" name="Common Allergies and Intolerances" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="68">
               <a:s>define &quot;Common Allergies and Intolerances&quot;:
  </a:s>
               <a:s r="67">
                  <a:s>
                     <a:s r="62">
                        <a:s r="61">
                           <a:s>
                              <a:s>&quot;All Allergies and Intolerances&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> A</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="66">
                     <a:s>where </a:s>
                     <a:s r="66">
                        <a:s r="64">
                           <a:s r="63">
                              <a:s>A</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="64">
                              <a:s>code</a:s>
                           </a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="65">
                           <a:s>&quot;Common allergy substances&quot;</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="67" locator="73:3-74:47" xsi:type="Query">
            <source localId="62" locator="73:3-73:36" alias="A">
               <expression localId="61" locator="73:3-73:34" name="All Allergies and Intolerances" xsi:type="ExpressionRef"/>
            </source>
            <where localId="66" locator="74:5-74:47" xsi:type="InValueSet">
               <code localId="64" locator="74:11-74:16" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="code" scope="A" xsi:type="Property"/>
               </code>
               <valueset localId="65" locator="74:21-74:47" name="Common allergy substances" preserve="true"/>
            </where>
         </expression>
      </def>
      <def localId="72" locator="76:1-77:72" name="Active Confirmed Common Allergies and Intolerances" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="72">
               <a:s>define &quot;Active Confirmed Common Allergies and Intolerances&quot;:
  </a:s>
               <a:s r="71">
                  <a:s r="70">
                     <a:s r="69">
                        <a:s>&quot;Common Allergies and Intolerances&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="70">
                        <a:s>allergyActive()</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="71">
                     <a:s>allergyConfirmed()</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="71" locator="77:3-77:72" name="allergyConfirmed" libraryName="UC" xsi:type="FunctionRef">
            <operand localId="70" locator="77:3-77:53" name="allergyActive" libraryName="UC" xsi:type="FunctionRef">
               <operand localId="69" locator="77:3-77:37" name="Common Allergies and Intolerances" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="86" locator="80:1-84:34" name="No Known Allergies (Not Asked)" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="86">
               <a:s>// No Known Allergies (Not Asked)
define &quot;No Known Allergies (Not Asked)&quot;:
  </a:s>
               <a:s r="85">
                  <a:s>
                     <a:s r="74">
                        <a:s r="73">
                           <a:s>
                              <a:s>&quot;All Allergies and Intolerances&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> A</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="84">
                     <a:s>where </a:s>
                     <a:s r="84">
                        <a:s r="81">
                           <a:s r="78">
                              <a:s r="76">
                                 <a:s r="75">
                                    <a:s>A</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="76">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="77">
                                 <a:s>&quot;No known allergy (situation)&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      and </a:s>
                           <a:s r="80">
                              <a:s r="79">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="80">
                                 <a:s>isAllergyActive()</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="83">
                           <a:s r="82">
                              <a:s>A</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="83">
                              <a:s>isAllergyUnconfirmed()</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="85" locator="81:3-84:34" xsi:type="Query">
            <source localId="74" locator="81:3-81:36" alias="A">
               <expression localId="73" locator="81:3-81:34" name="All Allergies and Intolerances" xsi:type="ExpressionRef"/>
            </source>
            <where localId="84" locator="82:5-84:34" xsi:type="And">
               <operand localId="81" locator="82:11-83:29" xsi:type="And">
                  <operand localId="78" locator="82:11-82:49" xsi:type="Equivalent">
                     <operand localId="76" locator="82:11-82:16" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="code" scope="A" xsi:type="Property"/>
                     </operand>
                     <operand xsi:type="ToConcept">
                        <operand localId="77" locator="82:20-82:49" name="No known allergy (situation)" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
                  <operand localId="80" locator="83:11-83:29" name="isAllergyActive" libraryName="UC" xsi:type="FunctionRef">
                     <operand localId="79" locator="83:11" name="A" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="83" locator="84:11-84:34" name="isAllergyUnconfirmed" libraryName="UC" xsi:type="FunctionRef">
                  <operand localId="82" locator="84:11" name="A" xsi:type="AliasRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="100" locator="87:1-91:32" name="No Known Allergies (Confirmed)" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="100">
               <a:s>// No Known Allergies (Confirmed)
define &quot;No Known Allergies (Confirmed)&quot;:
  </a:s>
               <a:s r="99">
                  <a:s>
                     <a:s r="88">
                        <a:s r="87">
                           <a:s>
                              <a:s>&quot;All Allergies and Intolerances&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> A</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="98">
                     <a:s>where </a:s>
                     <a:s r="98">
                        <a:s r="95">
                           <a:s r="92">
                              <a:s r="90">
                                 <a:s r="89">
                                    <a:s>A</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="90">
                                    <a:s>code</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> ~ </a:s>
                              <a:s r="91">
                                 <a:s>&quot;No known allergy (situation)&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      and </a:s>
                           <a:s r="94">
                              <a:s r="93">
                                 <a:s>A</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="94">
                                 <a:s>isAllergyActive()</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="97">
                           <a:s r="96">
                              <a:s>A</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="97">
                              <a:s>isAllergyConfirmed()</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="99" locator="88:3-91:32" xsi:type="Query">
            <source localId="88" locator="88:3-88:36" alias="A">
               <expression localId="87" locator="88:3-88:34" name="All Allergies and Intolerances" xsi:type="ExpressionRef"/>
            </source>
            <where localId="98" locator="89:5-91:32" xsi:type="And">
               <operand localId="95" locator="89:11-90:29" xsi:type="And">
                  <operand localId="92" locator="89:11-89:49" xsi:type="Equivalent">
                     <operand localId="90" locator="89:11-89:16" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="code" scope="A" xsi:type="Property"/>
                     </operand>
                     <operand xsi:type="ToConcept">
                        <operand localId="91" locator="89:20-89:49" name="No known allergy (situation)" xsi:type="CodeRef"/>
                     </operand>
                  </operand>
                  <operand localId="94" locator="90:11-90:29" name="isAllergyActive" libraryName="UC" xsi:type="FunctionRef">
                     <operand localId="93" locator="90:11" name="A" xsi:type="AliasRef"/>
                  </operand>
               </operand>
               <operand localId="97" locator="91:11-91:32" name="isAllergyConfirmed" libraryName="UC" xsi:type="FunctionRef">
                  <operand localId="96" locator="91:11" name="A" xsi:type="AliasRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="102" locator="103:1-104:15" name="All Conditions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns all problem list items, encounter diagnoses, and health concerns"/>
            <a:t name="comment" value="This definition returns all conditions of any category conforming to the US Core 3.1.1&#xa;[Condition](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-condition.html) profile.&#xa;Conditions returned by this definition include records with any clinical status (including none) and&#xa;any verification status (including none)."/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition"/>
            <a:s r="102">
               <a:s>// Condition

/*
@description: Returns all problem list items, encounter diagnoses, and health concerns
@comment: This definition returns all conditions of any category conforming to the US Core 3.1.1
[Condition](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-condition.html) profile.
Conditions returned by this definition include records with any clinical status (including none) and
any verification status (including none).
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition
*/
define &quot;All Conditions&quot;:
  </a:s>
               <a:s r="101">
                  <a:s>[&quot;Condition&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="101" locator="104:3-104:15" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" xsi:type="Retrieve"/>
      </def>
      <def localId="108" locator="106:1-108:31" name="All Problem List Items" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="108">
               <a:s>define &quot;All Problem List Items&quot;:
  </a:s>
               <a:s r="107">
                  <a:s>
                     <a:s r="104">
                        <a:s r="103">
                           <a:s>
                              <a:s>&quot;All Conditions&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="106">
                     <a:s>where </a:s>
                     <a:s r="106">
                        <a:s r="105">
                           <a:s>C</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="106">
                           <a:s>isProblemListItem()</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="107" locator="107:3-108:31" xsi:type="Query">
            <source localId="104" locator="107:3-107:20" alias="C">
               <expression localId="103" locator="107:3-107:18" name="All Conditions" xsi:type="ExpressionRef"/>
            </source>
            <where localId="106" locator="108:5-108:31" name="isProblemListItem" libraryName="UC" xsi:type="FunctionRef">
               <operand localId="105" locator="108:11" name="C" xsi:type="AliasRef"/>
            </where>
         </expression>
      </def>
      <def localId="112" locator="110:1-111:47" name="Active Confirmed Problem List Items" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="112">
               <a:s>define &quot;Active Confirmed Problem List Items&quot;:
  </a:s>
               <a:s r="111">
                  <a:s r="110">
                     <a:s r="109">
                        <a:s>&quot;All Problem List Items&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="110">
                        <a:s>active()</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="111">
                     <a:s>confirmed()</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="111" locator="111:3-111:47" name="confirmed" libraryName="UC" xsi:type="FunctionRef">
            <operand localId="110" locator="111:3-111:35" name="active" libraryName="UC" xsi:type="FunctionRef">
               <operand localId="109" locator="111:3-111:26" name="All Problem List Items" xsi:type="ExpressionRef"/>
            </operand>
         </expression>
      </def>
      <def localId="118" locator="113:1-115:34" name="All Encounter Diagnoses" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="118">
               <a:s>define &quot;All Encounter Diagnoses&quot;:
  </a:s>
               <a:s r="117">
                  <a:s>
                     <a:s r="114">
                        <a:s r="113">
                           <a:s>
                              <a:s>&quot;All Conditions&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="116">
                     <a:s>where </a:s>
                     <a:s r="116">
                        <a:s r="115">
                           <a:s>C</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="116">
                           <a:s>isEncounterDiagnosis()</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="117" locator="114:3-115:34" xsi:type="Query">
            <source localId="114" locator="114:3-114:20" alias="C">
               <expression localId="113" locator="114:3-114:18" name="All Conditions" xsi:type="ExpressionRef"/>
            </source>
            <where localId="116" locator="115:5-115:34" name="isEncounterDiagnosis" libraryName="UC" xsi:type="FunctionRef">
               <operand localId="115" locator="115:11" name="C" xsi:type="AliasRef"/>
            </where>
         </expression>
      </def>
      <def localId="124" locator="117:1-119:29" name="All Health Concerns" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="124">
               <a:s>define &quot;All Health Concerns&quot;:
  </a:s>
               <a:s r="123">
                  <a:s>
                     <a:s r="120">
                        <a:s r="119">
                           <a:s>
                              <a:s>&quot;All Conditions&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> C</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="122">
                     <a:s>where </a:s>
                     <a:s r="122">
                        <a:s r="121">
                           <a:s>C</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="122">
                           <a:s>isHealthConcern()</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="123" locator="118:3-119:29" xsi:type="Query">
            <source localId="120" locator="118:3-118:20" alias="C">
               <expression localId="119" locator="118:3-118:18" name="All Conditions" xsi:type="ExpressionRef"/>
            </source>
            <where localId="122" locator="119:5-119:29" name="isHealthConcern" libraryName="UC" xsi:type="FunctionRef">
               <operand localId="121" locator="119:11" name="C" xsi:type="AliasRef"/>
            </where>
         </expression>
      </def>
      <def localId="126" locator="127:1-128:48" name="All Diagnostic Reports for Laboratory Results" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Diagnostic Report for Laboratory Results](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-lab.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab"/>
            <a:s r="126">
               <a:s>// Laboratory Diagnostic Report

/*
@comment: [Diagnostic Report for Laboratory Results](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-lab.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab
*/
define &quot;All Diagnostic Reports for Laboratory Results&quot;:
  </a:s>
               <a:s r="125">
                  <a:s>[&quot;DiagnosticReportProfileLaboratoryReporting&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="125" locator="128:3-128:48" dataType="fhir:DiagnosticReport" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab" xsi:type="Retrieve"/>
      </def>
      <def localId="128" locator="136:1-137:41" name="All Diagnostic Report Notes" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Diagnostic Report Note](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-note.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note"/>
            <a:s r="128">
               <a:s>// Diagnostic Report

/*
@comment: [Diagnostic Report Note](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-note.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note
*/
define &quot;All Diagnostic Report Notes&quot;:
  </a:s>
               <a:s r="127">
                  <a:s>[&quot;DiagnosticReportProfileNoteExchange&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="127" locator="137:3-137:41" dataType="fhir:DiagnosticReport" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note" xsi:type="Retrieve"/>
      </def>
      <def localId="130" locator="145:1-146:22" name="All Encounters" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Encounter](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-encounter.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter"/>
            <a:s r="130">
               <a:s>// Encounter

/*
@comment: [Encounter](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-encounter.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter 
*/
define &quot;All Encounters&quot;:
  </a:s>
               <a:s r="129">
                  <a:s>[&quot;EncounterProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="129" locator="146:3-146:22" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" xsi:type="Retrieve"/>
      </def>
      <def localId="138" locator="148:1-150:31" name="All Performed Encounters" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="138">
               <a:s>define &quot;All Performed Encounters&quot;:
  </a:s>
               <a:s r="137">
                  <a:s>
                     <a:s r="132">
                        <a:s r="131">
                           <a:s>
                              <a:s>&quot;All Encounters&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> E</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="136">
                     <a:s>where </a:s>
                     <a:s r="136">
                        <a:s r="134">
                           <a:s r="133">
                              <a:s>E</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="134">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="135">
                           <a:s>'finished'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="137" locator="149:3-150:31" xsi:type="Query">
            <source localId="132" locator="149:3-149:20" alias="E">
               <expression localId="131" locator="149:3-149:18" name="All Encounters" xsi:type="ExpressionRef"/>
            </source>
            <where localId="136" locator="150:5-150:31" xsi:type="Equal">
               <operand localId="134" locator="150:11-150:18" path="value" xsi:type="Property">
                  <source path="status" scope="E" xsi:type="Property"/>
               </operand>
               <operand localId="135" locator="150:22-150:31" valueType="t:String" value="finished" xsi:type="Literal"/>
            </where>
         </expression>
      </def>
      <def localId="140" locator="158:1-159:25" name="All Immunizations" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Immunization](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-immunization.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization"/>
            <a:s r="140">
               <a:s>// Immunization

/*
@comment: [Immunization](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-immunization.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization
*/
define &quot;All Immunizations&quot;:
  </a:s>
               <a:s r="139">
                  <a:s>[&quot;ImmunizationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="139" locator="159:3-159:25" dataType="fhir:Immunization" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization" xsi:type="Retrieve"/>
      </def>
      <def localId="148" locator="161:1-163:32" name="All Completed Immunizations" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="148">
               <a:s>define &quot;All Completed Immunizations&quot;:
  </a:s>
               <a:s r="147">
                  <a:s>
                     <a:s r="142">
                        <a:s r="141">
                           <a:s>
                              <a:s>&quot;All Immunizations&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> I</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="146">
                     <a:s>where </a:s>
                     <a:s r="146">
                        <a:s r="144">
                           <a:s r="143">
                              <a:s>I</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="144">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="145">
                           <a:s>'completed'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="147" locator="162:3-163:32" xsi:type="Query">
            <source localId="142" locator="162:3-162:23" alias="I">
               <expression localId="141" locator="162:3-162:21" name="All Immunizations" xsi:type="ExpressionRef"/>
            </source>
            <where localId="146" locator="163:5-163:32" xsi:type="Equal">
               <operand localId="144" locator="163:11-163:18" path="value" xsi:type="Property">
                  <source path="status" scope="I" xsi:type="Property"/>
               </operand>
               <operand localId="145" locator="163:22-163:32" valueType="t:String" value="completed" xsi:type="Literal"/>
            </where>
         </expression>
      </def>
      <def localId="150" locator="171:1-172:30" name="All Implantable Devices" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Implantable Device](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-implantable-device.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device"/>
            <a:s r="150">
               <a:s>// Implantable Device

/*
@comment: [Implantable Device](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-implantable-device.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device
*/
define &quot;All Implantable Devices&quot;:
  </a:s>
               <a:s r="149">
                  <a:s>[&quot;ImplantableDeviceProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="149" locator="172:3-172:30" dataType="fhir:Device" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device" xsi:type="Retrieve"/>
      </def>
      <def localId="152" locator="181:1-182:40" name="All Laboratory Results" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns all laboratory results"/>
            <a:t name="comment" value="[Laboratory Result](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-observation-lab.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab"/>
            <a:s r="152">
               <a:s>// Laboratory Result

/*
@description: Returns all laboratory results
@comment: [Laboratory Result](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-observation-lab.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab
*/
define &quot;All Laboratory Results&quot;:
  </a:s>
               <a:s r="151">
                  <a:s>[&quot;LaboratoryResultObservationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="151" locator="182:3-182:40" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab" xsi:type="Retrieve"/>
      </def>
      <def localId="164" locator="184:1-186:72" name="Resulted Laboratory Results" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="164">
               <a:s>define &quot;Resulted Laboratory Results&quot;:
  </a:s>
               <a:s r="163">
                  <a:s>
                     <a:s r="154">
                        <a:s r="153">
                           <a:s>
                              <a:s>&quot;All Laboratory Results&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> L</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="162">
                     <a:s>where </a:s>
                     <a:s r="162">
                        <a:s r="156">
                           <a:s r="155">
                              <a:s>L</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="156">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="161">
                           <a:s>{ </a:s>
                           <a:s r="157">
                              <a:s>'preliminary'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="158">
                              <a:s>'final'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="159">
                              <a:s>'amended'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="160">
                              <a:s>'corrected'</a:s>
                           </a:s>
                           <a:s> }</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="163" locator="185:3-186:72" xsi:type="Query">
            <source localId="154" locator="185:3-185:28" alias="L">
               <expression localId="153" locator="185:3-185:26" name="All Laboratory Results" xsi:type="ExpressionRef"/>
            </source>
            <where localId="162" locator="186:5-186:72" xsi:type="In">
               <operand localId="156" locator="186:11-186:18" path="value" xsi:type="Property">
                  <source path="status" scope="L" xsi:type="Property"/>
               </operand>
               <operand localId="161" locator="186:23-186:72" xsi:type="List">
                  <element localId="157" locator="186:25-186:37" valueType="t:String" value="preliminary" xsi:type="Literal"/>
                  <element localId="158" locator="186:40-186:46" valueType="t:String" value="final" xsi:type="Literal"/>
                  <element localId="159" locator="186:49-186:57" valueType="t:String" value="amended" xsi:type="Literal"/>
                  <element localId="160" locator="186:60-186:70" valueType="t:String" value="corrected" xsi:type="Literal"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="167" locator="198:1-199:30" name="All Medication Requests" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="167">
               <a:s>define &quot;All Medication Requests&quot;:
  </a:s>
               <a:s r="166">
                  <a:s>[&quot;MedicationRequestProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="166" locator="199:3-199:30" dataType="fhir:MedicationRequest" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest" xsi:type="Retrieve"/>
      </def>
      <def localId="170" locator="195:1-196:44" name="Most Recent Medication Request" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns all medication requests"/>
            <a:t name="comment" value="[Medication Request](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medicationrequest.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest"/>
            <a:s r="170">
               <a:s>// Medication Request

/*
@description: Returns all medication requests
@comment: [Medication Request](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medicationrequest.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest
*/
define &quot;Most Recent Medication Request&quot;:
  </a:s>
               <a:s r="169">
                  <a:s r="165">
                     <a:s>UC</a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="169">
                     <a:s>MostRecentMR(</a:s>
                     <a:s r="168">
                        <a:s>&quot;All Medication Requests&quot;</a:s>
                     </a:s>
                     <a:s>)</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="169" locator="196:3-196:44" name="MostRecentMR" libraryName="UC" xsi:type="FunctionRef">
            <operand localId="168" locator="196:19-196:43" name="All Medication Requests" xsi:type="ExpressionRef"/>
         </expression>
      </def>
      <def localId="188" locator="201:1-204:101" name="Active Medication Orders" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="188">
               <a:s>define &quot;Active Medication Orders&quot;:
  </a:s>
               <a:s r="187">
                  <a:s>
                     <a:s r="172">
                        <a:s r="171">
                           <a:s>
                              <a:s>&quot;All Medication Requests&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> M</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="186">
                     <a:s>where </a:s>
                     <a:s r="186">
                        <a:s r="176">
                           <a:s r="174">
                              <a:s r="173">
                                 <a:s>M</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="174">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="175">
                              <a:s>'active'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="185">
                           <a:s r="178">
                              <a:s r="177">
                                 <a:s>M</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="178">
                                 <a:s>intent</a:s>
                              </a:s>
                           </a:s>
                           <a:s> in </a:s>
                           <a:s r="184">
                              <a:s>{ </a:s>
                              <a:s r="179">
                                 <a:s>'order'</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="180">
                                 <a:s>'original-order'</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="181">
                                 <a:s>'reflex-order'</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="182">
                                 <a:s>'filler-order'</a:s>
                              </a:s>
                              <a:s>, </a:s>
                              <a:s r="183">
                                 <a:s>'instance-order'</a:s>
                              </a:s>
                              <a:s> }</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="187" locator="202:3-204:101" xsi:type="Query">
            <source localId="172" locator="202:3-202:29" alias="M">
               <expression localId="171" locator="202:3-202:27" name="All Medication Requests" xsi:type="ExpressionRef"/>
            </source>
            <where localId="186" locator="203:5-204:101" xsi:type="And">
               <operand localId="176" locator="203:11-203:29" xsi:type="Equal">
                  <operand localId="174" locator="203:11-203:18" path="value" xsi:type="Property">
                     <source path="status" scope="M" xsi:type="Property"/>
                  </operand>
                  <operand localId="175" locator="203:22-203:29" valueType="t:String" value="active" xsi:type="Literal"/>
               </operand>
               <operand localId="185" locator="204:11-204:101" xsi:type="In">
                  <operand localId="178" locator="204:11-204:18" path="value" xsi:type="Property">
                     <source path="intent" scope="M" xsi:type="Property"/>
                  </operand>
                  <operand localId="184" locator="204:23-204:101" xsi:type="List">
                     <element localId="179" locator="204:25-204:31" valueType="t:String" value="order" xsi:type="Literal"/>
                     <element localId="180" locator="204:34-204:49" valueType="t:String" value="original-order" xsi:type="Literal"/>
                     <element localId="181" locator="204:52-204:65" valueType="t:String" value="reflex-order" xsi:type="Literal"/>
                     <element localId="182" locator="204:68-204:81" valueType="t:String" value="filler-order" xsi:type="Literal"/>
                     <element localId="183" locator="204:84-204:99" valueType="t:String" value="instance-order" xsi:type="Literal"/>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="190" locator="206:1-207:23" name="All Medications" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="190">
               <a:s>define &quot;All Medications&quot;:
  </a:s>
               <a:s r="189">
                  <a:s>[&quot;MedicationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="189" locator="207:3-207:23" dataType="fhir:Medication" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" xsi:type="Retrieve"/>
      </def>
      <def localId="192" locator="215:1-216:42" name="Pediatric BMI for Age" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Pediatric BMI for Age](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-bmi-for-age.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age"/>
            <a:s r="192">
               <a:s>// Pediatric BMI for Age

/*
@comment: [Pediatric BMI for Age](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-bmi-for-age.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age
*/
define &quot;Pediatric BMI for Age&quot;:
  </a:s>
               <a:s r="191">
                  <a:s>[&quot;PediatricBMIforAgeObservationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="191" locator="216:3-216:42" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age" xsi:type="Retrieve"/>
      </def>
      <def localId="194" locator="235:1-236:48" name="Pediatric Weight for Height" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Pediatric Head Circumference Percentile](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-head-occipital-frontal-circumference-percentile.html)"/>
            <a:t name="profile" value="&quot;All Pediatric Head Circumference Percentile Measurements&quot;:"/>
            <a:t name="comment" value="[Pediatric Weight for Height](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-weight-for-height.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height"/>
            <a:s r="194">
               <a:s>// Pediatric Head Circumference Percentile

/*
@comment: [Pediatric Head Circumference Percentile](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-head-occipital-frontal-circumference-percentile.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/head-occipital-frontal-circumference-percentile
*/
//define &quot;All Pediatric Head Circumference Percentile Measurements&quot;:
  //TODO - profile not in modelinfo
  //UsCorePediatricHeadOccipitalFrontalCircumferencePercentileProfile


// Pediatric Weight for Height

/*
@comment: [Pediatric Weight for Height](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-weight-for-height.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height
*/
define &quot;Pediatric Weight for Height&quot;:
  </a:s>
               <a:s r="193">
                  <a:s>[&quot;PediatricWeightForHeightObservationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="193" locator="236:3-236:48" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height" xsi:type="Retrieve"/>
      </def>
      <def localId="206" locator="244:1-246:78" name="All Procedures" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Procedure](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-procedure.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure"/>
            <a:s r="206">
               <a:s>// Procedure

/*
@comment: [Procedure](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-procedure.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure
*/
define &quot;All Procedures&quot;:
  </a:s>
               <a:s r="205">
                  <a:s>
                     <a:s r="196">
                        <a:s r="195">
                           <a:s r="195">
                              <a:s>[&quot;ProcedureProfile&quot;]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> P</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="204">
                     <a:s>where </a:s>
                     <a:s r="204">
                        <a:s r="198">
                           <a:s r="197">
                              <a:s>P</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="198">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> in </a:s>
                        <a:s r="203">
                           <a:s>{ </a:s>
                           <a:s r="199">
                              <a:s>'preparation'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="200">
                              <a:s>'in-progress'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="201">
                              <a:s>'on-hold'</a:s>
                           </a:s>
                           <a:s>, </a:s>
                           <a:s r="202">
                              <a:s>'completed'</a:s>
                           </a:s>
                           <a:s> }</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="205" locator="245:3-246:78" xsi:type="Query">
            <source localId="196" locator="245:3-245:24" alias="P">
               <expression localId="195" locator="245:3-245:22" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" xsi:type="Retrieve"/>
            </source>
            <where localId="204" locator="246:5-246:78" xsi:type="In">
               <operand localId="198" locator="246:11-246:18" path="value" xsi:type="Property">
                  <source path="status" scope="P" xsi:type="Property"/>
               </operand>
               <operand localId="203" locator="246:23-246:78" xsi:type="List">
                  <element localId="199" locator="246:25-246:37" valueType="t:String" value="preparation" xsi:type="Literal"/>
                  <element localId="200" locator="246:40-246:52" valueType="t:String" value="in-progress" xsi:type="Literal"/>
                  <element localId="201" locator="246:55-246:63" valueType="t:String" value="on-hold" xsi:type="Literal"/>
                  <element localId="202" locator="246:66-246:76" valueType="t:String" value="completed" xsi:type="Literal"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="214" locator="248:1-250:32" name="All Performed Procedures" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="214">
               <a:s>define &quot;All Performed Procedures&quot;:
  </a:s>
               <a:s r="213">
                  <a:s>
                     <a:s r="208">
                        <a:s r="207">
                           <a:s>
                              <a:s>&quot;All Procedures&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s> P</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="212">
                     <a:s>where </a:s>
                     <a:s r="212">
                        <a:s r="210">
                           <a:s r="209">
                              <a:s>P</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="210">
                              <a:s>status</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="211">
                           <a:s>'completed'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="213" locator="249:3-250:32" xsi:type="Query">
            <source localId="208" locator="249:3-249:20" alias="P">
               <expression localId="207" locator="249:3-249:18" name="All Procedures" xsi:type="ExpressionRef"/>
            </source>
            <where localId="212" locator="250:5-250:32" xsi:type="Equal">
               <operand localId="210" locator="250:11-250:18" path="value" xsi:type="Property">
                  <source path="status" scope="P" xsi:type="Property"/>
               </operand>
               <operand localId="211" locator="250:22-250:32" valueType="t:String" value="completed" xsi:type="Literal"/>
            </where>
         </expression>
      </def>
      <def localId="216" locator="258:1-259:26" name="Pulse Oximetry" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Pulse Oximetry](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-pulse-oximetry.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry"/>
            <a:s r="216">
               <a:s>// Pulse Oximetry

/*
@comment: [Pulse Oximetry](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-pulse-oximetry.html)
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry
*/
define &quot;Pulse Oximetry&quot;:
  </a:s>
               <a:s r="215">
                  <a:s>[&quot;PulseOximetryProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="215" locator="259:3-259:26" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry" xsi:type="Retrieve"/>
      </def>
      <def localId="218" locator="270:1-271:26" name="Smoking Status" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns all smoking status observations"/>
            <a:t name="comment" value="This definition returns all smoking status observations conforming to the US Core 3.1.1&#xa;[Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)&#xa;profile."/>
            <a:t name="profile" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus"/>
            <a:s r="218">
               <a:s>// Smoking Status

/*
@description: Returns all smoking status observations
@comment: This definition returns all smoking status observations conforming to the US Core 3.1.1
[Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)
profile.
@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus
*/
define &quot;Smoking Status&quot;:
  </a:s>
               <a:s r="217">
                  <a:s>[&quot;SmokingStatusProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="217" locator="271:3-271:26" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus" xsi:type="Retrieve"/>
      </def>
      <def localId="230" locator="279:1-284:3" name="Most Recent Smoking Status" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="description" value="Returns the most recent smoking status"/>
            <a:t name="comment" value="This definition returns the most recent (by issued time) smoking status observation conforming to the&#xa;US Core 3.1.1 [Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)&#xa;profile."/>
            <a:s r="230">
               <a:s>/*
@description: Returns the most recent smoking status
@comment: This definition returns the most recent (by issued time) smoking status observation conforming to the
US Core 3.1.1 [Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)
profile.
*/
define &quot;Most Recent Smoking Status&quot;:
  </a:s>
               <a:s r="229">
                  <a:s>Last(
    </a:s>
                  <a:s r="228">
                     <a:s>
                        <a:s r="220">
                           <a:s r="219">
                              <a:s>
                                 <a:s>&quot;Smoking Status&quot;</a:s>
                              </a:s>
                           </a:s>
                           <a:s> SS</a:s>
                        </a:s>
                     </a:s>
                     <a:s>
        </a:s>
                     <a:s r="224">
                        <a:s>where </a:s>
                        <a:s r="224">
                           <a:s r="222">
                              <a:s r="221">
                                 <a:s>SS</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="222">
                                 <a:s>status</a:s>
                              </a:s>
                           </a:s>
                           <a:s> = </a:s>
                           <a:s r="223">
                              <a:s>'final'</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                     <a:s>
        </a:s>
                     <a:s r="227">
                        <a:s>sort by </a:s>
                        <a:s r="226">
                           <a:s r="225">
                              <a:s>issued</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
                  <a:s>
  )</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="229" locator="280:3-284:3" xsi:type="Last">
            <source localId="228" locator="281:5-283:22" xsi:type="Query">
               <source localId="220" locator="281:5-281:23" alias="SS">
                  <expression localId="219" locator="281:5-281:20" name="Smoking Status" xsi:type="ExpressionRef"/>
               </source>
               <where localId="224" locator="282:9-282:33" xsi:type="Equal">
                  <operand localId="222" locator="282:15-282:23" path="value" xsi:type="Property">
                     <source path="status" scope="SS" xsi:type="Property"/>
                  </operand>
                  <operand localId="223" locator="282:27-282:33" valueType="t:String" value="final" xsi:type="Literal"/>
               </where>
               <sort localId="227" locator="283:9-283:22">
                  <by localId="226" locator="283:17-283:22" direction="asc" xsi:type="ByExpression">
                     <expression localId="225" locator="283:17-283:22" path="value" xsi:type="Property">
                        <source name="issued" xsi:type="IdentifierRef"/>
                     </expression>
                  </by>
               </sort>
            </source>
         </expression>
      </def>
      <def localId="232" locator="292:1-293:29" name="All Vital Signs Panels" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Vital Signs Panel](http://hl7.org/fhir/R4/vitalspanel.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/vitalspanel"/>
            <a:s r="232">
               <a:s>// Vital Signs Panel

/*
@comment: [Vital Signs Panel](http://hl7.org/fhir/R4/vitalspanel.html)
@profile: http://hl7.org/fhir/StructureDefinition/vitalspanel
*/
define &quot;All Vital Signs Panels&quot;:
  </a:s>
               <a:s r="231">
                  <a:s>[&quot;observation-vitalspanel&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="231" locator="293:3-293:29" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/vitalspanel" xsi:type="Retrieve"/>
      </def>
      <def localId="234" locator="301:1-302:26" name="All Respiratory Rate Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Respiratory Rate](http://hl7.org/fhir/R4/resprate.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/resprate"/>
            <a:s r="234">
               <a:s>// Respiratory Rate

/*
@comment: [Respiratory Rate](http://hl7.org/fhir/R4/resprate.html)
@profile: http://hl7.org/fhir/StructureDefinition/resprate
*/
define &quot;All Respiratory Rate Measurements&quot;:
  </a:s>
               <a:s r="233">
                  <a:s>[&quot;observation-resprate&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="233" locator="302:3-302:26" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/resprate" xsi:type="Retrieve"/>
      </def>
      <def localId="236" locator="310:1-311:27" name="All Heart Rate Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Heart Rate](http://hl7.org/fhir/R4/heartrate.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/heartrate"/>
            <a:s r="236">
               <a:s>// Heart Rate

/*
@comment: [Heart Rate](http://hl7.org/fhir/R4/heartrate.html)
@profile:http://hl7.org/fhir/StructureDefinition/heartrate
*/
define &quot;All Heart Rate Measurements&quot;:
  </a:s>
               <a:s r="235">
                  <a:s>[&quot;observation-heartrate&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="235" locator="311:3-311:27" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/heartrate" xsi:type="Retrieve"/>
      </def>
      <def localId="238" locator="319:1-320:27" name="All Oxygen Saturation Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Oxygen Saturation](http://hl7.org/fhir/R4/oxygensat.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/oxygensat"/>
            <a:s r="238">
               <a:s>// Oxygen Saturation

/*
@comment: [Oxygen Saturation](http://hl7.org/fhir/R4/oxygensat.html)
@profile: http://hl7.org/fhir/StructureDefinition/oxygensat
*/
define &quot;All Oxygen Saturation Measurements&quot;:
  </a:s>
               <a:s r="237">
                  <a:s>[&quot;observation-oxygensat&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="237" locator="320:3-320:27" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/oxygensat" xsi:type="Retrieve"/>
      </def>
      <def localId="240" locator="328:1-329:26" name="All Body Temperature Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Body Temperature](http://hl7.org/fhir/R4/bodytemp.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/bodytemp"/>
            <a:s r="240">
               <a:s>// Body Temperature

/*
@comment: [Body Temperature](http://hl7.org/fhir/R4/bodytemp.html)
@profile: http://hl7.org/fhir/StructureDefinition/bodytemp
*/
define &quot;All Body Temperature Measurements&quot;:
  </a:s>
               <a:s r="239">
                  <a:s>[&quot;observation-bodytemp&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="239" locator="329:3-329:26" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodytemp" xsi:type="Retrieve"/>
      </def>
      <def localId="242" locator="337:1-338:28" name="All Body Height Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Body Height](http://hl7.org/fhir/R4/bodyheight.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/bodyheight"/>
            <a:s r="242">
               <a:s>// Body Height

/*
@comment: [Body Height](http://hl7.org/fhir/R4/bodyheight.html)
@profile: http://hl7.org/fhir/StructureDefinition/bodyheight
*/
define &quot;All Body Height Measurements&quot;:
  </a:s>
               <a:s r="241">
                  <a:s>[&quot;observation-bodyheight&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="241" locator="338:3-338:28" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodyheight" xsi:type="Retrieve"/>
      </def>
      <def localId="244" locator="346:1-347:28" name="All Head Circumference Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Head Circumference](http://hl7.org/fhir/R4/headcircum.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/headcircum"/>
            <a:s r="244">
               <a:s>// Head Circumference

/*
@comment: [Head Circumference](http://hl7.org/fhir/R4/headcircum.html)
@profile: http://hl7.org/fhir/StructureDefinition/headcircum
*/
define &quot;All Head Circumference Measurements&quot;:
  </a:s>
               <a:s r="243">
                  <a:s>[&quot;observation-headcircum&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="243" locator="347:3-347:28" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/headcircum" xsi:type="Retrieve"/>
      </def>
      <def localId="246" locator="355:1-356:28" name="All Body Weight Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Body Weight](http://hl7.org/fhir/R4/bodyweight.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/bodyweight"/>
            <a:s r="246">
               <a:s>// Body Weight

/*
@comment: [Body Weight](http://hl7.org/fhir/R4/bodyweight.html)
@profile: http://hl7.org/fhir/StructureDefinition/bodyweight
*/
define &quot;All Body Weight Measurements&quot;:
  </a:s>
               <a:s r="245">
                  <a:s>[&quot;observation-bodyweight&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="245" locator="356:3-356:28" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodyweight" xsi:type="Retrieve"/>
      </def>
      <def localId="248" locator="364:1-365:21" name="All Body Mass Index Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Body Mass Index](http://hl7.org/fhir/R4/bmi.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/bmi"/>
            <a:s r="248">
               <a:s>// Body Mass Index

/*
@comment: [Body Mass Index](http://hl7.org/fhir/R4/bmi.html)
@profile: http://hl7.org/fhir/StructureDefinition/bmi
*/
define &quot;All Body Mass Index Measurements&quot;:
  </a:s>
               <a:s r="247">
                  <a:s>[&quot;observation-bmi&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="247" locator="365:3-365:21" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bmi" xsi:type="Retrieve"/>
      </def>
      <def localId="250" locator="373:1-374:20" name="All Blood Pressure Measurements" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:t name="comment" value="[Blood Pressure](http://hl7.org/fhir/R4/bp.html)"/>
            <a:t name="profile" value="http://hl7.org/fhir/StructureDefinition/bp"/>
            <a:s r="250">
               <a:s>// Blood Pressure

/*
@comment: [Blood Pressure](http://hl7.org/fhir/R4/bp.html)
@profile: http://hl7.org/fhir/StructureDefinition/bp
*/
define &quot;All Blood Pressure Measurements&quot;:
  </a:s>
               <a:s r="249">
                  <a:s>[&quot;observation-bp&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="249" locator="374:3-374:20" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bp" xsi:type="Retrieve"/>
      </def>
      <def localId="254" locator="377:1-378:52" name="Systolic Blood Pressure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="254">
               <a:s>// Systolic Blood Pressure
define &quot;Systolic Blood Pressure&quot;:
  </a:s>
               <a:s r="253">
                  <a:s r="252">
                     <a:s r="251">
                        <a:s>&quot;All Blood Pressure Measurements&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="252">
                        <a:s>SystolicBP</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="253">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="253" locator="378:3-378:52" xsi:type="Query">
            <source alias="$this">
               <expression localId="252" locator="378:3-378:46" xsi:type="Query">
                  <source alias="$this">
                     <expression localId="251" locator="378:3-378:35" name="All Blood Pressure Measurements" xsi:type="ExpressionRef"/>
                  </source>
                  <where xsi:type="Not">
                     <operand xsi:type="IsNull">
                        <operand xsi:type="SingletonFrom">
                           <operand xsi:type="Query">
                              <source alias="$this">
                                 <expression path="component" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </expression>
                              </source>
                              <where xsi:type="And">
                                 <operand xsi:type="Equal">
                                    <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="system" xsi:type="Property">
                                          <source xsi:type="First">
                                             <source path="coding" xsi:type="Property">
                                                <source path="code" scope="$this" xsi:type="Property"/>
                                             </source>
                                          </source>
                                       </operand>
                                    </operand>
                                    <operand valueType="t:String" value="http://loinc.org" xsi:type="Literal"/>
                                 </operand>
                                 <operand xsi:type="Equal">
                                    <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="code" xsi:type="Property">
                                          <source xsi:type="First">
                                             <source path="coding" xsi:type="Property">
                                                <source path="code" scope="$this" xsi:type="Property"/>
                                             </source>
                                          </source>
                                       </operand>
                                    </operand>
                                    <operand valueType="t:String" value="8480-6" xsi:type="Literal"/>
                                 </operand>
                              </where>
                           </operand>
                        </operand>
                     </operand>
                  </where>
                  <return distinct="false">
                     <expression xsi:type="SingletonFrom">
                        <operand xsi:type="Query">
                           <source alias="$this">
                              <expression path="component" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </source>
                           <where xsi:type="And">
                              <operand xsi:type="Equal">
                                 <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="system" xsi:type="Property">
                                       <source xsi:type="First">
                                          <source path="coding" xsi:type="Property">
                                             <source path="code" scope="$this" xsi:type="Property"/>
                                          </source>
                                       </source>
                                    </operand>
                                 </operand>
                                 <operand valueType="t:String" value="http://loinc.org" xsi:type="Literal"/>
                              </operand>
                              <operand xsi:type="Equal">
                                 <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="code" xsi:type="Property">
                                       <source xsi:type="First">
                                          <source path="coding" xsi:type="Property">
                                             <source path="code" scope="$this" xsi:type="Property"/>
                                          </source>
                                       </source>
                                    </operand>
                                 </operand>
                                 <operand valueType="t:String" value="8480-6" xsi:type="Literal"/>
                              </operand>
                           </where>
                        </operand>
                     </expression>
                  </return>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="value" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </operand>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="value" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </operand>
               </expression>
            </return>
         </expression>
      </def>
      <def localId="258" locator="381:1-382:53" name="Diastolic Blood Pressure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="258">
               <a:s>// Diastolic Blood Pressure
define &quot;Diastolic Blood Pressure&quot;:
  </a:s>
               <a:s r="257">
                  <a:s r="256">
                     <a:s r="255">
                        <a:s>&quot;All Blood Pressure Measurements&quot;</a:s>
                     </a:s>
                     <a:s>.</a:s>
                     <a:s r="256">
                        <a:s>DiastolicBP</a:s>
                     </a:s>
                  </a:s>
                  <a:s>.</a:s>
                  <a:s r="257">
                     <a:s>value</a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="257" locator="382:3-382:53" xsi:type="Query">
            <source alias="$this">
               <expression localId="256" locator="382:3-382:47" xsi:type="Query">
                  <source alias="$this">
                     <expression localId="255" locator="382:3-382:35" name="All Blood Pressure Measurements" xsi:type="ExpressionRef"/>
                  </source>
                  <where xsi:type="Not">
                     <operand xsi:type="IsNull">
                        <operand xsi:type="SingletonFrom">
                           <operand xsi:type="Query">
                              <source alias="$this">
                                 <expression path="component" xsi:type="Property">
                                    <source name="$this" xsi:type="AliasRef"/>
                                 </expression>
                              </source>
                              <where xsi:type="And">
                                 <operand xsi:type="Equal">
                                    <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="system" xsi:type="Property">
                                          <source xsi:type="First">
                                             <source path="coding" xsi:type="Property">
                                                <source path="code" scope="$this" xsi:type="Property"/>
                                             </source>
                                          </source>
                                       </operand>
                                    </operand>
                                    <operand valueType="t:String" value="http://loinc.org" xsi:type="Literal"/>
                                 </operand>
                                 <operand xsi:type="Equal">
                                    <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                       <operand path="code" xsi:type="Property">
                                          <source xsi:type="First">
                                             <source path="coding" xsi:type="Property">
                                                <source path="code" scope="$this" xsi:type="Property"/>
                                             </source>
                                          </source>
                                       </operand>
                                    </operand>
                                    <operand valueType="t:String" value="8462-4" xsi:type="Literal"/>
                                 </operand>
                              </where>
                           </operand>
                        </operand>
                     </operand>
                  </where>
                  <return distinct="false">
                     <expression xsi:type="SingletonFrom">
                        <operand xsi:type="Query">
                           <source alias="$this">
                              <expression path="component" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </source>
                           <where xsi:type="And">
                              <operand xsi:type="Equal">
                                 <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="system" xsi:type="Property">
                                       <source xsi:type="First">
                                          <source path="coding" xsi:type="Property">
                                             <source path="code" scope="$this" xsi:type="Property"/>
                                          </source>
                                       </source>
                                    </operand>
                                 </operand>
                                 <operand valueType="t:String" value="http://loinc.org" xsi:type="Literal"/>
                              </operand>
                              <operand xsi:type="Equal">
                                 <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                    <operand path="code" xsi:type="Property">
                                       <source xsi:type="First">
                                          <source path="coding" xsi:type="Property">
                                             <source path="code" scope="$this" xsi:type="Property"/>
                                          </source>
                                       </source>
                                    </operand>
                                 </operand>
                                 <operand valueType="t:String" value="8462-4" xsi:type="Literal"/>
                              </operand>
                           </where>
                        </operand>
                     </expression>
                  </return>
               </expression>
            </source>
            <where xsi:type="Not">
               <operand xsi:type="IsNull">
                  <operand name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="value" xsi:type="Property">
                        <source name="$this" xsi:type="AliasRef"/>
                     </operand>
                  </operand>
               </operand>
            </where>
            <return distinct="false">
               <expression name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand path="value" xsi:type="Property">
                     <source name="$this" xsi:type="AliasRef"/>
                  </operand>
               </expression>
            </return>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorVersion" : "2.7.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "s" : {
            "r" : "258",
            "s" : [ {
               "value" : [ "","library USCoreElements version '0.1.0'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "USCoreElements",
         "system" : "http://fhir.org/guides/cqf/us/common",
         "version" : "0.1.0"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "3:1-3:28",
            "localIdentifier" : "USCore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCore" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "2",
            "locator" : "5:1-5:37",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/cqf/us/common/FHIRHelpers",
            "version" : "4.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "2",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.1.000'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "3",
            "locator" : "6:1-6:46",
            "localIdentifier" : "UC",
            "path" : "http://fhir.org/guides/cqf/us/common/USCoreCommon",
            "version" : "0.1.0",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "3",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCoreCommon" ]
                     } ]
                  }, {
                     "value" : [ " version ","'0.1.0'"," called ","UC" ]
                  } ]
               }
            } ]
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "4",
            "locator" : "8:1-8:102",
            "name" : "Common allergy substances",
            "id" : "http://hl7.org/fhir/us/core/ValueSet/us-core-allergy-substance",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "4",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Common allergy substances\"",": ","'http://hl7.org/fhir/us/core/ValueSet/us-core-allergy-substance'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "6",
            "locator" : "10:1-10:65",
            "name" : "No known allergy (situation)",
            "id" : "716186003",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "6",
                  "s" : [ {
                     "value" : [ "","code ","\"No known allergy (situation)\"",": ","'716186003'"," from " ]
                  }, {
                     "r" : "5",
                     "s" : [ {
                        "value" : [ "UC",".","SNOMEDCT" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "5",
               "locator" : "10:55-10:65",
               "name" : "SNOMEDCT",
               "libraryName" : "UC"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "locator" : "12:1-12:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "12:1-12:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "12:1-12:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "15",
            "locator" : "14:1-18:3",
            "name" : "Usual Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "15",
                  "s" : [ {
                     "value" : [ "","define ","\"Usual Name\"",":\n  " ]
                  }, {
                     "r" : "14",
                     "s" : [ {
                        "value" : [ "First","(\n    " ]
                     }, {
                        "r" : "13",
                        "s" : [ {
                           "s" : [ {
                              "r" : "8",
                              "s" : [ {
                                 "r" : "7",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Patient",".","name" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","name" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n      " ]
                        }, {
                           "r" : "12",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "12",
                              "s" : [ {
                                 "r" : "10",
                                 "s" : [ {
                                    "r" : "9",
                                    "s" : [ {
                                       "value" : [ "name" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "10",
                                    "s" : [ {
                                       "value" : [ "use" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "11",
                                 "s" : [ {
                                    "value" : [ "'usual'" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  )" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "14",
               "locator" : "15:3-18:3",
               "type" : "First",
               "source" : {
                  "localId" : "13",
                  "locator" : "16:5-17:30",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "8",
                     "locator" : "16:5-16:21",
                     "alias" : "name",
                     "expression" : {
                        "localId" : "7",
                        "locator" : "16:5-16:16",
                        "path" : "name",
                        "type" : "Property",
                        "source" : {
                           "name" : "Patient",
                           "type" : "ExpressionRef"
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "12",
                     "locator" : "17:7-17:30",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "10",
                        "locator" : "17:13-17:20",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "use",
                           "scope" : "name",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "11",
                        "locator" : "17:24-17:30",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "usual",
                        "type" : "Literal"
                     } ]
                  }
               }
            }
         }, {
            "localId" : "24",
            "locator" : "20:1-24:3",
            "name" : "Official Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "24",
                  "s" : [ {
                     "value" : [ "","define ","\"Official Name\"",":\n  " ]
                  }, {
                     "r" : "23",
                     "s" : [ {
                        "value" : [ "First","(\n    " ]
                     }, {
                        "r" : "22",
                        "s" : [ {
                           "s" : [ {
                              "r" : "17",
                              "s" : [ {
                                 "r" : "16",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Patient",".","name" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","name" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n      " ]
                        }, {
                           "r" : "21",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "21",
                              "s" : [ {
                                 "r" : "19",
                                 "s" : [ {
                                    "r" : "18",
                                    "s" : [ {
                                       "value" : [ "name" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "19",
                                    "s" : [ {
                                       "value" : [ "use" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "20",
                                 "s" : [ {
                                    "value" : [ "'official'" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  )" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "23",
               "locator" : "21:3-24:3",
               "type" : "First",
               "source" : {
                  "localId" : "22",
                  "locator" : "22:5-23:33",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "17",
                     "locator" : "22:5-22:21",
                     "alias" : "name",
                     "expression" : {
                        "localId" : "16",
                        "locator" : "22:5-22:16",
                        "path" : "name",
                        "type" : "Property",
                        "source" : {
                           "name" : "Patient",
                           "type" : "ExpressionRef"
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "21",
                     "locator" : "23:7-23:33",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "19",
                        "locator" : "23:13-23:20",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "use",
                           "scope" : "name",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "20",
                        "locator" : "23:24-23:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "official",
                        "type" : "Literal"
                     } ]
                  }
               }
            }
         }, {
            "localId" : "40",
            "locator" : "26:1-30:3",
            "name" : "First Occurrence of Non-Official, Non-Usual Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "40",
                  "s" : [ {
                     "value" : [ "","define ","\"First Occurrence of Non-Official, Non-Usual Name\"",":\n  " ]
                  }, {
                     "r" : "39",
                     "s" : [ {
                        "value" : [ "First","(\n    " ]
                     }, {
                        "r" : "38",
                        "s" : [ {
                           "s" : [ {
                              "r" : "26",
                              "s" : [ {
                                 "r" : "25",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "Patient",".","name" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","name" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n      " ]
                        }, {
                           "r" : "37",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "37",
                              "s" : [ {
                                 "r" : "31",
                                 "s" : [ {
                                    "value" : [ "not" ]
                                 }, {
                                    "r" : "30",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "30",
                                       "s" : [ {
                                          "r" : "28",
                                          "s" : [ {
                                             "r" : "27",
                                             "s" : [ {
                                                "value" : [ "name" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "28",
                                             "s" : [ {
                                                "value" : [ "use" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","~"," " ]
                                       }, {
                                          "r" : "29",
                                          "s" : [ {
                                             "value" : [ "'official'" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " and " ]
                              }, {
                                 "r" : "36",
                                 "s" : [ {
                                    "value" : [ "not" ]
                                 }, {
                                    "r" : "35",
                                    "s" : [ {
                                       "value" : [ "(" ]
                                    }, {
                                       "r" : "35",
                                       "s" : [ {
                                          "r" : "33",
                                          "s" : [ {
                                             "r" : "32",
                                             "s" : [ {
                                                "value" : [ "name" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "33",
                                             "s" : [ {
                                                "value" : [ "use" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","~"," " ]
                                       }, {
                                          "r" : "34",
                                          "s" : [ {
                                             "value" : [ "'usual'" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ ")" ]
                                    } ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  )" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "39",
               "locator" : "27:3-30:3",
               "type" : "First",
               "source" : {
                  "localId" : "38",
                  "locator" : "28:5-29:66",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "26",
                     "locator" : "28:5-28:21",
                     "alias" : "name",
                     "expression" : {
                        "localId" : "25",
                        "locator" : "28:5-28:16",
                        "path" : "name",
                        "type" : "Property",
                        "source" : {
                           "name" : "Patient",
                           "type" : "ExpressionRef"
                        }
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "37",
                     "locator" : "29:7-29:66",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "31",
                        "locator" : "29:13-29:38",
                        "type" : "Not",
                        "operand" : {
                           "localId" : "30",
                           "locator" : "29:16-29:38",
                           "type" : "Equivalent",
                           "operand" : [ {
                              "localId" : "28",
                              "locator" : "29:17-29:24",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "path" : "use",
                                 "scope" : "name",
                                 "type" : "Property"
                              }
                           }, {
                              "localId" : "29",
                              "locator" : "29:28-29:37",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "official",
                              "type" : "Literal"
                           } ]
                        }
                     }, {
                        "localId" : "36",
                        "locator" : "29:44-29:66",
                        "type" : "Not",
                        "operand" : {
                           "localId" : "35",
                           "locator" : "29:47-29:66",
                           "type" : "Equivalent",
                           "operand" : [ {
                              "localId" : "33",
                              "locator" : "29:48-29:55",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "path" : "use",
                                 "scope" : "name",
                                 "type" : "Property"
                              }
                           }, {
                              "localId" : "34",
                              "locator" : "29:59-29:65",
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "usual",
                              "type" : "Literal"
                           } ]
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "45",
            "locator" : "32:1-33:93",
            "name" : "Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "45",
                  "s" : [ {
                     "value" : [ "","define ","\"Name\"",":\n  " ]
                  }, {
                     "r" : "44",
                     "s" : [ {
                        "value" : [ "Coalesce","(" ]
                     }, {
                        "r" : "41",
                        "s" : [ {
                           "value" : [ "\"Official Name\"" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "42",
                        "s" : [ {
                           "value" : [ "\"Usual Name\"" ]
                        } ]
                     }, {
                        "value" : [ ", " ]
                     }, {
                        "r" : "43",
                        "s" : [ {
                           "value" : [ "\"First Occurrence of Non-Official, Non-Usual Name\"" ]
                        } ]
                     }, {
                        "value" : [ ")" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "44",
               "locator" : "33:3-33:93",
               "type" : "Coalesce",
               "operand" : [ {
                  "localId" : "41",
                  "locator" : "33:12-33:26",
                  "name" : "Official Name",
                  "type" : "ExpressionRef"
               }, {
                  "localId" : "42",
                  "locator" : "33:29-33:40",
                  "name" : "Usual Name",
                  "type" : "ExpressionRef"
               }, {
                  "localId" : "43",
                  "locator" : "33:43-33:92",
                  "name" : "First Occurrence of Non-Official, Non-Usual Name",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "48",
            "locator" : "43:1-44:15",
            "name" : "Last Name",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "48",
                  "s" : [ {
                     "value" : [ "// TODO: Correct this once USCore.HumanName.given works as expected\n// define \"First Name\":\n//   \"Name\".given[0]\n\n// TODO: Correct this once USCore.HumanName.given works as expected\n// define \"Middle Names\":\n//   Combine(Skip(\"Name\".given, 1), ' ')\n","define ","\"Last Name\"",":\n  " ]
                  }, {
                     "r" : "47",
                     "s" : [ {
                        "r" : "46",
                        "s" : [ {
                           "value" : [ "\"Name\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "47",
                        "s" : [ {
                           "value" : [ "family" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "47",
               "locator" : "44:3-44:15",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "family",
                  "type" : "Property",
                  "source" : {
                     "localId" : "46",
                     "locator" : "44:3-44:8",
                     "name" : "Name",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "51",
            "locator" : "47:1-49:15",
            "name" : "Name - First Middle(s) Last",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "51",
                  "s" : [ {
                     "value" : [ "// TODO: Correct this once USCore.HumanName.given works as expected\n","define ","\"Name - First Middle(s) Last\"",":\n  //Combine(\"Name\".given, ' ') + ' ' + \"Name\".family\n  " ]
                  }, {
                     "r" : "50",
                     "s" : [ {
                        "r" : "49",
                        "s" : [ {
                           "value" : [ "\"Name\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "50",
                        "s" : [ {
                           "value" : [ "family" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "50",
               "locator" : "49:3-49:15",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "family",
                  "type" : "Property",
                  "source" : {
                     "localId" : "49",
                     "locator" : "49:3-49:8",
                     "name" : "Name",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "54",
            "locator" : "52:1-54:15",
            "name" : "Name - Last, First Middle(s)",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "54",
                  "s" : [ {
                     "value" : [ "// TODO: Correct this once USCore.HumanName.given works as expected\n","define ","\"Name - Last, First Middle(s)\"",":\n  //\"Name\".family + ', ' + Combine(\"Name\".given, ' ')\n  " ]
                  }, {
                     "r" : "53",
                     "s" : [ {
                        "r" : "52",
                        "s" : [ {
                           "value" : [ "\"Name\"" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "53",
                        "s" : [ {
                           "value" : [ "family" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "53",
               "locator" : "54:3-54:15",
               "path" : "value",
               "type" : "Property",
               "source" : {
                  "path" : "family",
                  "type" : "Property",
                  "source" : {
                     "localId" : "52",
                     "locator" : "54:3-54:8",
                     "name" : "Name",
                     "type" : "ExpressionRef"
                  }
               }
            }
         }, {
            "localId" : "56",
            "locator" : "66:1-67:24",
            "name" : "All Allergies and Intolerances",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns all allergies and intolerances"
               }, {
                  "name" : "comment",
                  "value" : "This definition returns all allergies and intolerances conforming to the US Core 3.1.1\n[AllergyIntolerance](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-allergyintolerance.html) profile.\nAllergies and intolerances returned by this definition include records with any clinical status (including none)\nand any verification status (including none)."
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance"
               } ],
               "s" : {
                  "r" : "56",
                  "s" : [ {
                     "value" : [ "// Allergy/Intolerance\n\n/*\n@description: Returns all allergies and intolerances\n@comment: This definition returns all allergies and intolerances conforming to the US Core 3.1.1\n[AllergyIntolerance](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-allergyintolerance.html) profile.\nAllergies and intolerances returned by this definition include records with any clinical status (including none)\nand any verification status (including none).\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance\n*/\n","define ","\"All Allergies and Intolerances\"",":\n  " ]
                  }, {
                     "r" : "55",
                     "s" : [ {
                        "value" : [ "[","\"AllergyIntolerance\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "55",
               "locator" : "67:3-67:24",
               "dataType" : "{http://hl7.org/fhir}AllergyIntolerance",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "60",
            "locator" : "69:1-70:69",
            "name" : "Active Confirmed Allergies and Intolerances",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "60",
                  "s" : [ {
                     "value" : [ "","define ","\"Active Confirmed Allergies and Intolerances\"",":\n  " ]
                  }, {
                     "r" : "59",
                     "s" : [ {
                        "r" : "58",
                        "s" : [ {
                           "r" : "57",
                           "s" : [ {
                              "value" : [ "\"All Allergies and Intolerances\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "58",
                           "s" : [ {
                              "value" : [ "allergyActive","()" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "59",
                        "s" : [ {
                           "value" : [ "allergyConfirmed","()" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "59",
               "locator" : "70:3-70:69",
               "name" : "allergyConfirmed",
               "libraryName" : "UC",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "58",
                  "locator" : "70:3-70:50",
                  "name" : "allergyActive",
                  "libraryName" : "UC",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "57",
                     "locator" : "70:3-70:34",
                     "name" : "All Allergies and Intolerances",
                     "type" : "ExpressionRef"
                  } ]
               } ]
            }
         }, {
            "localId" : "68",
            "locator" : "72:1-74:47",
            "name" : "Common Allergies and Intolerances",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "68",
                  "s" : [ {
                     "value" : [ "","define ","\"Common Allergies and Intolerances\"",":\n  " ]
                  }, {
                     "r" : "67",
                     "s" : [ {
                        "s" : [ {
                           "r" : "62",
                           "s" : [ {
                              "r" : "61",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Allergies and Intolerances\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","A" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "66",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "66",
                           "s" : [ {
                              "r" : "64",
                              "s" : [ {
                                 "r" : "63",
                                 "s" : [ {
                                    "value" : [ "A" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "64",
                                 "s" : [ {
                                    "value" : [ "code" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "65",
                              "s" : [ {
                                 "value" : [ "\"Common allergy substances\"" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "67",
               "locator" : "73:3-74:47",
               "type" : "Query",
               "source" : [ {
                  "localId" : "62",
                  "locator" : "73:3-73:36",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "61",
                     "locator" : "73:3-73:34",
                     "name" : "All Allergies and Intolerances",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "66",
                  "locator" : "74:5-74:47",
                  "type" : "InValueSet",
                  "code" : {
                     "localId" : "64",
                     "locator" : "74:11-74:16",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "code",
                        "scope" : "A",
                        "type" : "Property"
                     } ]
                  },
                  "valueset" : {
                     "localId" : "65",
                     "locator" : "74:21-74:47",
                     "name" : "Common allergy substances",
                     "preserve" : true
                  }
               }
            }
         }, {
            "localId" : "72",
            "locator" : "76:1-77:72",
            "name" : "Active Confirmed Common Allergies and Intolerances",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "72",
                  "s" : [ {
                     "value" : [ "","define ","\"Active Confirmed Common Allergies and Intolerances\"",":\n  " ]
                  }, {
                     "r" : "71",
                     "s" : [ {
                        "r" : "70",
                        "s" : [ {
                           "r" : "69",
                           "s" : [ {
                              "value" : [ "\"Common Allergies and Intolerances\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "70",
                           "s" : [ {
                              "value" : [ "allergyActive","()" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "71",
                        "s" : [ {
                           "value" : [ "allergyConfirmed","()" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "71",
               "locator" : "77:3-77:72",
               "name" : "allergyConfirmed",
               "libraryName" : "UC",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "70",
                  "locator" : "77:3-77:53",
                  "name" : "allergyActive",
                  "libraryName" : "UC",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "69",
                     "locator" : "77:3-77:37",
                     "name" : "Common Allergies and Intolerances",
                     "type" : "ExpressionRef"
                  } ]
               } ]
            }
         }, {
            "localId" : "86",
            "locator" : "80:1-84:34",
            "name" : "No Known Allergies (Not Asked)",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "86",
                  "s" : [ {
                     "value" : [ "// No Known Allergies (Not Asked)\n","define ","\"No Known Allergies (Not Asked)\"",":\n  " ]
                  }, {
                     "r" : "85",
                     "s" : [ {
                        "s" : [ {
                           "r" : "74",
                           "s" : [ {
                              "r" : "73",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Allergies and Intolerances\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","A" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "84",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "84",
                           "s" : [ {
                              "r" : "81",
                              "s" : [ {
                                 "r" : "78",
                                 "s" : [ {
                                    "r" : "76",
                                    "s" : [ {
                                       "r" : "75",
                                       "s" : [ {
                                          "value" : [ "A" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "76",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "77",
                                    "s" : [ {
                                       "value" : [ "\"No known allergy (situation)\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      and " ]
                              }, {
                                 "r" : "80",
                                 "s" : [ {
                                    "r" : "79",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "80",
                                    "s" : [ {
                                       "value" : [ "isAllergyActive","()" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "83",
                              "s" : [ {
                                 "r" : "82",
                                 "s" : [ {
                                    "value" : [ "A" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "83",
                                 "s" : [ {
                                    "value" : [ "isAllergyUnconfirmed","()" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "85",
               "locator" : "81:3-84:34",
               "type" : "Query",
               "source" : [ {
                  "localId" : "74",
                  "locator" : "81:3-81:36",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "73",
                     "locator" : "81:3-81:34",
                     "name" : "All Allergies and Intolerances",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "84",
                  "locator" : "82:5-84:34",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "81",
                     "locator" : "82:11-83:29",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "78",
                        "locator" : "82:11-82:49",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "76",
                           "locator" : "82:11-82:16",
                           "name" : "ToConcept",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "code",
                              "scope" : "A",
                              "type" : "Property"
                           } ]
                        }, {
                           "type" : "ToConcept",
                           "operand" : {
                              "localId" : "77",
                              "locator" : "82:20-82:49",
                              "name" : "No known allergy (situation)",
                              "type" : "CodeRef"
                           }
                        } ]
                     }, {
                        "localId" : "80",
                        "locator" : "83:11-83:29",
                        "name" : "isAllergyActive",
                        "libraryName" : "UC",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "79",
                           "locator" : "83:11",
                           "name" : "A",
                           "type" : "AliasRef"
                        } ]
                     } ]
                  }, {
                     "localId" : "83",
                     "locator" : "84:11-84:34",
                     "name" : "isAllergyUnconfirmed",
                     "libraryName" : "UC",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "82",
                        "locator" : "84:11",
                        "name" : "A",
                        "type" : "AliasRef"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "100",
            "locator" : "87:1-91:32",
            "name" : "No Known Allergies (Confirmed)",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "100",
                  "s" : [ {
                     "value" : [ "// No Known Allergies (Confirmed)\n","define ","\"No Known Allergies (Confirmed)\"",":\n  " ]
                  }, {
                     "r" : "99",
                     "s" : [ {
                        "s" : [ {
                           "r" : "88",
                           "s" : [ {
                              "r" : "87",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Allergies and Intolerances\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","A" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "98",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "98",
                           "s" : [ {
                              "r" : "95",
                              "s" : [ {
                                 "r" : "92",
                                 "s" : [ {
                                    "r" : "90",
                                    "s" : [ {
                                       "r" : "89",
                                       "s" : [ {
                                          "value" : [ "A" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "90",
                                       "s" : [ {
                                          "value" : [ "code" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " ","~"," " ]
                                 }, {
                                    "r" : "91",
                                    "s" : [ {
                                       "value" : [ "\"No known allergy (situation)\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      and " ]
                              }, {
                                 "r" : "94",
                                 "s" : [ {
                                    "r" : "93",
                                    "s" : [ {
                                       "value" : [ "A" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "94",
                                    "s" : [ {
                                       "value" : [ "isAllergyActive","()" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "97",
                              "s" : [ {
                                 "r" : "96",
                                 "s" : [ {
                                    "value" : [ "A" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "97",
                                 "s" : [ {
                                    "value" : [ "isAllergyConfirmed","()" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "99",
               "locator" : "88:3-91:32",
               "type" : "Query",
               "source" : [ {
                  "localId" : "88",
                  "locator" : "88:3-88:36",
                  "alias" : "A",
                  "expression" : {
                     "localId" : "87",
                     "locator" : "88:3-88:34",
                     "name" : "All Allergies and Intolerances",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "98",
                  "locator" : "89:5-91:32",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "95",
                     "locator" : "89:11-90:29",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "92",
                        "locator" : "89:11-89:49",
                        "type" : "Equivalent",
                        "operand" : [ {
                           "localId" : "90",
                           "locator" : "89:11-89:16",
                           "name" : "ToConcept",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "code",
                              "scope" : "A",
                              "type" : "Property"
                           } ]
                        }, {
                           "type" : "ToConcept",
                           "operand" : {
                              "localId" : "91",
                              "locator" : "89:20-89:49",
                              "name" : "No known allergy (situation)",
                              "type" : "CodeRef"
                           }
                        } ]
                     }, {
                        "localId" : "94",
                        "locator" : "90:11-90:29",
                        "name" : "isAllergyActive",
                        "libraryName" : "UC",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "localId" : "93",
                           "locator" : "90:11",
                           "name" : "A",
                           "type" : "AliasRef"
                        } ]
                     } ]
                  }, {
                     "localId" : "97",
                     "locator" : "91:11-91:32",
                     "name" : "isAllergyConfirmed",
                     "libraryName" : "UC",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "localId" : "96",
                        "locator" : "91:11",
                        "name" : "A",
                        "type" : "AliasRef"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "102",
            "locator" : "103:1-104:15",
            "name" : "All Conditions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns all problem list items, encounter diagnoses, and health concerns"
               }, {
                  "name" : "comment",
                  "value" : "This definition returns all conditions of any category conforming to the US Core 3.1.1\n[Condition](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-condition.html) profile.\nConditions returned by this definition include records with any clinical status (including none) and\nany verification status (including none)."
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition"
               } ],
               "s" : {
                  "r" : "102",
                  "s" : [ {
                     "value" : [ "// Condition\n\n/*\n@description: Returns all problem list items, encounter diagnoses, and health concerns\n@comment: This definition returns all conditions of any category conforming to the US Core 3.1.1\n[Condition](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-condition.html) profile.\nConditions returned by this definition include records with any clinical status (including none) and\nany verification status (including none).\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition\n*/\n","define ","\"All Conditions\"",":\n  " ]
                  }, {
                     "r" : "101",
                     "s" : [ {
                        "value" : [ "[","\"Condition\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "101",
               "locator" : "104:3-104:15",
               "dataType" : "{http://hl7.org/fhir}Condition",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "108",
            "locator" : "106:1-108:31",
            "name" : "All Problem List Items",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "108",
                  "s" : [ {
                     "value" : [ "","define ","\"All Problem List Items\"",":\n  " ]
                  }, {
                     "r" : "107",
                     "s" : [ {
                        "s" : [ {
                           "r" : "104",
                           "s" : [ {
                              "r" : "103",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Conditions\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "106",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "106",
                           "s" : [ {
                              "r" : "105",
                              "s" : [ {
                                 "value" : [ "C" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "106",
                              "s" : [ {
                                 "value" : [ "isProblemListItem","()" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "107",
               "locator" : "107:3-108:31",
               "type" : "Query",
               "source" : [ {
                  "localId" : "104",
                  "locator" : "107:3-107:20",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "103",
                     "locator" : "107:3-107:18",
                     "name" : "All Conditions",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "106",
                  "locator" : "108:5-108:31",
                  "name" : "isProblemListItem",
                  "libraryName" : "UC",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "105",
                     "locator" : "108:11",
                     "name" : "C",
                     "type" : "AliasRef"
                  } ]
               }
            }
         }, {
            "localId" : "112",
            "locator" : "110:1-111:47",
            "name" : "Active Confirmed Problem List Items",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "112",
                  "s" : [ {
                     "value" : [ "","define ","\"Active Confirmed Problem List Items\"",":\n  " ]
                  }, {
                     "r" : "111",
                     "s" : [ {
                        "r" : "110",
                        "s" : [ {
                           "r" : "109",
                           "s" : [ {
                              "value" : [ "\"All Problem List Items\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "110",
                           "s" : [ {
                              "value" : [ "active","()" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "111",
                        "s" : [ {
                           "value" : [ "confirmed","()" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "111",
               "locator" : "111:3-111:47",
               "name" : "confirmed",
               "libraryName" : "UC",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "110",
                  "locator" : "111:3-111:35",
                  "name" : "active",
                  "libraryName" : "UC",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "109",
                     "locator" : "111:3-111:26",
                     "name" : "All Problem List Items",
                     "type" : "ExpressionRef"
                  } ]
               } ]
            }
         }, {
            "localId" : "118",
            "locator" : "113:1-115:34",
            "name" : "All Encounter Diagnoses",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "118",
                  "s" : [ {
                     "value" : [ "","define ","\"All Encounter Diagnoses\"",":\n  " ]
                  }, {
                     "r" : "117",
                     "s" : [ {
                        "s" : [ {
                           "r" : "114",
                           "s" : [ {
                              "r" : "113",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Conditions\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "116",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "116",
                           "s" : [ {
                              "r" : "115",
                              "s" : [ {
                                 "value" : [ "C" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "116",
                              "s" : [ {
                                 "value" : [ "isEncounterDiagnosis","()" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "117",
               "locator" : "114:3-115:34",
               "type" : "Query",
               "source" : [ {
                  "localId" : "114",
                  "locator" : "114:3-114:20",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "113",
                     "locator" : "114:3-114:18",
                     "name" : "All Conditions",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "116",
                  "locator" : "115:5-115:34",
                  "name" : "isEncounterDiagnosis",
                  "libraryName" : "UC",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "115",
                     "locator" : "115:11",
                     "name" : "C",
                     "type" : "AliasRef"
                  } ]
               }
            }
         }, {
            "localId" : "124",
            "locator" : "117:1-119:29",
            "name" : "All Health Concerns",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "124",
                  "s" : [ {
                     "value" : [ "","define ","\"All Health Concerns\"",":\n  " ]
                  }, {
                     "r" : "123",
                     "s" : [ {
                        "s" : [ {
                           "r" : "120",
                           "s" : [ {
                              "r" : "119",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Conditions\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","C" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "122",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "122",
                           "s" : [ {
                              "r" : "121",
                              "s" : [ {
                                 "value" : [ "C" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "122",
                              "s" : [ {
                                 "value" : [ "isHealthConcern","()" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "123",
               "locator" : "118:3-119:29",
               "type" : "Query",
               "source" : [ {
                  "localId" : "120",
                  "locator" : "118:3-118:20",
                  "alias" : "C",
                  "expression" : {
                     "localId" : "119",
                     "locator" : "118:3-118:18",
                     "name" : "All Conditions",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "122",
                  "locator" : "119:5-119:29",
                  "name" : "isHealthConcern",
                  "libraryName" : "UC",
                  "type" : "FunctionRef",
                  "operand" : [ {
                     "localId" : "121",
                     "locator" : "119:11",
                     "name" : "C",
                     "type" : "AliasRef"
                  } ]
               }
            }
         }, {
            "localId" : "126",
            "locator" : "127:1-128:48",
            "name" : "All Diagnostic Reports for Laboratory Results",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Diagnostic Report for Laboratory Results](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-lab.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab"
               } ],
               "s" : {
                  "r" : "126",
                  "s" : [ {
                     "value" : [ "// Laboratory Diagnostic Report\n\n/*\n@comment: [Diagnostic Report for Laboratory Results](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-lab.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab\n*/\n","define ","\"All Diagnostic Reports for Laboratory Results\"",":\n  " ]
                  }, {
                     "r" : "125",
                     "s" : [ {
                        "value" : [ "[","\"DiagnosticReportProfileLaboratoryReporting\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "125",
               "locator" : "128:3-128:48",
               "dataType" : "{http://hl7.org/fhir}DiagnosticReport",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "128",
            "locator" : "136:1-137:41",
            "name" : "All Diagnostic Report Notes",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Diagnostic Report Note](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-note.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note"
               } ],
               "s" : {
                  "r" : "128",
                  "s" : [ {
                     "value" : [ "// Diagnostic Report\n\n/*\n@comment: [Diagnostic Report Note](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-diagnosticreport-note.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note\n*/\n","define ","\"All Diagnostic Report Notes\"",":\n  " ]
                  }, {
                     "r" : "127",
                     "s" : [ {
                        "value" : [ "[","\"DiagnosticReportProfileNoteExchange\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "127",
               "locator" : "137:3-137:41",
               "dataType" : "{http://hl7.org/fhir}DiagnosticReport",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "130",
            "locator" : "145:1-146:22",
            "name" : "All Encounters",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Encounter](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-encounter.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter"
               } ],
               "s" : {
                  "r" : "130",
                  "s" : [ {
                     "value" : [ "// Encounter\n\n/*\n@comment: [Encounter](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-encounter.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter \n*/\n","define ","\"All Encounters\"",":\n  " ]
                  }, {
                     "r" : "129",
                     "s" : [ {
                        "value" : [ "[","\"EncounterProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "129",
               "locator" : "146:3-146:22",
               "dataType" : "{http://hl7.org/fhir}Encounter",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "138",
            "locator" : "148:1-150:31",
            "name" : "All Performed Encounters",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "138",
                  "s" : [ {
                     "value" : [ "","define ","\"All Performed Encounters\"",":\n  " ]
                  }, {
                     "r" : "137",
                     "s" : [ {
                        "s" : [ {
                           "r" : "132",
                           "s" : [ {
                              "r" : "131",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Encounters\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","E" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "136",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "136",
                           "s" : [ {
                              "r" : "134",
                              "s" : [ {
                                 "r" : "133",
                                 "s" : [ {
                                    "value" : [ "E" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "134",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "135",
                              "s" : [ {
                                 "value" : [ "'finished'" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "137",
               "locator" : "149:3-150:31",
               "type" : "Query",
               "source" : [ {
                  "localId" : "132",
                  "locator" : "149:3-149:20",
                  "alias" : "E",
                  "expression" : {
                     "localId" : "131",
                     "locator" : "149:3-149:18",
                     "name" : "All Encounters",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "136",
                  "locator" : "150:5-150:31",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "134",
                     "locator" : "150:11-150:18",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "E",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "135",
                     "locator" : "150:22-150:31",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "finished",
                     "type" : "Literal"
                  } ]
               }
            }
         }, {
            "localId" : "140",
            "locator" : "158:1-159:25",
            "name" : "All Immunizations",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Immunization](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-immunization.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization"
               } ],
               "s" : {
                  "r" : "140",
                  "s" : [ {
                     "value" : [ "// Immunization\n\n/*\n@comment: [Immunization](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-immunization.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization\n*/\n","define ","\"All Immunizations\"",":\n  " ]
                  }, {
                     "r" : "139",
                     "s" : [ {
                        "value" : [ "[","\"ImmunizationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "139",
               "locator" : "159:3-159:25",
               "dataType" : "{http://hl7.org/fhir}Immunization",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "148",
            "locator" : "161:1-163:32",
            "name" : "All Completed Immunizations",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "148",
                  "s" : [ {
                     "value" : [ "","define ","\"All Completed Immunizations\"",":\n  " ]
                  }, {
                     "r" : "147",
                     "s" : [ {
                        "s" : [ {
                           "r" : "142",
                           "s" : [ {
                              "r" : "141",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Immunizations\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","I" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "146",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "146",
                           "s" : [ {
                              "r" : "144",
                              "s" : [ {
                                 "r" : "143",
                                 "s" : [ {
                                    "value" : [ "I" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "144",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "145",
                              "s" : [ {
                                 "value" : [ "'completed'" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "147",
               "locator" : "162:3-163:32",
               "type" : "Query",
               "source" : [ {
                  "localId" : "142",
                  "locator" : "162:3-162:23",
                  "alias" : "I",
                  "expression" : {
                     "localId" : "141",
                     "locator" : "162:3-162:21",
                     "name" : "All Immunizations",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "146",
                  "locator" : "163:5-163:32",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "144",
                     "locator" : "163:11-163:18",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "I",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "145",
                     "locator" : "163:22-163:32",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "completed",
                     "type" : "Literal"
                  } ]
               }
            }
         }, {
            "localId" : "150",
            "locator" : "171:1-172:30",
            "name" : "All Implantable Devices",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Implantable Device](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-implantable-device.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device"
               } ],
               "s" : {
                  "r" : "150",
                  "s" : [ {
                     "value" : [ "// Implantable Device\n\n/*\n@comment: [Implantable Device](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-implantable-device.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device\n*/\n","define ","\"All Implantable Devices\"",":\n  " ]
                  }, {
                     "r" : "149",
                     "s" : [ {
                        "value" : [ "[","\"ImplantableDeviceProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "149",
               "locator" : "172:3-172:30",
               "dataType" : "{http://hl7.org/fhir}Device",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "152",
            "locator" : "181:1-182:40",
            "name" : "All Laboratory Results",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns all laboratory results"
               }, {
                  "name" : "comment",
                  "value" : "[Laboratory Result](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-observation-lab.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab"
               } ],
               "s" : {
                  "r" : "152",
                  "s" : [ {
                     "value" : [ "// Laboratory Result\n\n/*\n@description: Returns all laboratory results\n@comment: [Laboratory Result](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-observation-lab.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab\n*/\n","define ","\"All Laboratory Results\"",":\n  " ]
                  }, {
                     "r" : "151",
                     "s" : [ {
                        "value" : [ "[","\"LaboratoryResultObservationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "151",
               "locator" : "182:3-182:40",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "164",
            "locator" : "184:1-186:72",
            "name" : "Resulted Laboratory Results",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "164",
                  "s" : [ {
                     "value" : [ "","define ","\"Resulted Laboratory Results\"",":\n  " ]
                  }, {
                     "r" : "163",
                     "s" : [ {
                        "s" : [ {
                           "r" : "154",
                           "s" : [ {
                              "r" : "153",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Laboratory Results\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","L" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "162",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "162",
                           "s" : [ {
                              "r" : "156",
                              "s" : [ {
                                 "r" : "155",
                                 "s" : [ {
                                    "value" : [ "L" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "156",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "161",
                              "s" : [ {
                                 "value" : [ "{ " ]
                              }, {
                                 "r" : "157",
                                 "s" : [ {
                                    "value" : [ "'preliminary'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "158",
                                 "s" : [ {
                                    "value" : [ "'final'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "159",
                                 "s" : [ {
                                    "value" : [ "'amended'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "160",
                                 "s" : [ {
                                    "value" : [ "'corrected'" ]
                                 } ]
                              }, {
                                 "value" : [ " }" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "163",
               "locator" : "185:3-186:72",
               "type" : "Query",
               "source" : [ {
                  "localId" : "154",
                  "locator" : "185:3-185:28",
                  "alias" : "L",
                  "expression" : {
                     "localId" : "153",
                     "locator" : "185:3-185:26",
                     "name" : "All Laboratory Results",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "162",
                  "locator" : "186:5-186:72",
                  "type" : "In",
                  "operand" : [ {
                     "localId" : "156",
                     "locator" : "186:11-186:18",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "L",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "161",
                     "locator" : "186:23-186:72",
                     "type" : "List",
                     "element" : [ {
                        "localId" : "157",
                        "locator" : "186:25-186:37",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "preliminary",
                        "type" : "Literal"
                     }, {
                        "localId" : "158",
                        "locator" : "186:40-186:46",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "final",
                        "type" : "Literal"
                     }, {
                        "localId" : "159",
                        "locator" : "186:49-186:57",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "amended",
                        "type" : "Literal"
                     }, {
                        "localId" : "160",
                        "locator" : "186:60-186:70",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "corrected",
                        "type" : "Literal"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "167",
            "locator" : "198:1-199:30",
            "name" : "All Medication Requests",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "167",
                  "s" : [ {
                     "value" : [ "","define ","\"All Medication Requests\"",":\n  " ]
                  }, {
                     "r" : "166",
                     "s" : [ {
                        "value" : [ "[","\"MedicationRequestProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "166",
               "locator" : "199:3-199:30",
               "dataType" : "{http://hl7.org/fhir}MedicationRequest",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "170",
            "locator" : "195:1-196:44",
            "name" : "Most Recent Medication Request",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns all medication requests"
               }, {
                  "name" : "comment",
                  "value" : "[Medication Request](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medicationrequest.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest"
               } ],
               "s" : {
                  "r" : "170",
                  "s" : [ {
                     "value" : [ "// Medication Request\n\n/*\n@description: Returns all medication requests\n@comment: [Medication Request](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medicationrequest.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest\n*/\n","define ","\"Most Recent Medication Request\"",":\n  " ]
                  }, {
                     "r" : "169",
                     "s" : [ {
                        "r" : "165",
                        "s" : [ {
                           "value" : [ "UC" ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "169",
                        "s" : [ {
                           "value" : [ "MostRecentMR","(" ]
                        }, {
                           "r" : "168",
                           "s" : [ {
                              "value" : [ "\"All Medication Requests\"" ]
                           } ]
                        }, {
                           "value" : [ ")" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "169",
               "locator" : "196:3-196:44",
               "name" : "MostRecentMR",
               "libraryName" : "UC",
               "type" : "FunctionRef",
               "operand" : [ {
                  "localId" : "168",
                  "locator" : "196:19-196:43",
                  "name" : "All Medication Requests",
                  "type" : "ExpressionRef"
               } ]
            }
         }, {
            "localId" : "188",
            "locator" : "201:1-204:101",
            "name" : "Active Medication Orders",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "188",
                  "s" : [ {
                     "value" : [ "","define ","\"Active Medication Orders\"",":\n  " ]
                  }, {
                     "r" : "187",
                     "s" : [ {
                        "s" : [ {
                           "r" : "172",
                           "s" : [ {
                              "r" : "171",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Medication Requests\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","M" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "186",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "186",
                           "s" : [ {
                              "r" : "176",
                              "s" : [ {
                                 "r" : "174",
                                 "s" : [ {
                                    "r" : "173",
                                    "s" : [ {
                                       "value" : [ "M" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "174",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "175",
                                 "s" : [ {
                                    "value" : [ "'active'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "185",
                              "s" : [ {
                                 "r" : "178",
                                 "s" : [ {
                                    "r" : "177",
                                    "s" : [ {
                                       "value" : [ "M" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "178",
                                    "s" : [ {
                                       "value" : [ "intent" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " in " ]
                              }, {
                                 "r" : "184",
                                 "s" : [ {
                                    "value" : [ "{ " ]
                                 }, {
                                    "r" : "179",
                                    "s" : [ {
                                       "value" : [ "'order'" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "180",
                                    "s" : [ {
                                       "value" : [ "'original-order'" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "181",
                                    "s" : [ {
                                       "value" : [ "'reflex-order'" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "182",
                                    "s" : [ {
                                       "value" : [ "'filler-order'" ]
                                    } ]
                                 }, {
                                    "value" : [ ", " ]
                                 }, {
                                    "r" : "183",
                                    "s" : [ {
                                       "value" : [ "'instance-order'" ]
                                    } ]
                                 }, {
                                    "value" : [ " }" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "187",
               "locator" : "202:3-204:101",
               "type" : "Query",
               "source" : [ {
                  "localId" : "172",
                  "locator" : "202:3-202:29",
                  "alias" : "M",
                  "expression" : {
                     "localId" : "171",
                     "locator" : "202:3-202:27",
                     "name" : "All Medication Requests",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "186",
                  "locator" : "203:5-204:101",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "176",
                     "locator" : "203:11-203:29",
                     "type" : "Equal",
                     "operand" : [ {
                        "localId" : "174",
                        "locator" : "203:11-203:18",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "scope" : "M",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "175",
                        "locator" : "203:22-203:29",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "active",
                        "type" : "Literal"
                     } ]
                  }, {
                     "localId" : "185",
                     "locator" : "204:11-204:101",
                     "type" : "In",
                     "operand" : [ {
                        "localId" : "178",
                        "locator" : "204:11-204:18",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "intent",
                           "scope" : "M",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "184",
                        "locator" : "204:23-204:101",
                        "type" : "List",
                        "element" : [ {
                           "localId" : "179",
                           "locator" : "204:25-204:31",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "order",
                           "type" : "Literal"
                        }, {
                           "localId" : "180",
                           "locator" : "204:34-204:49",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "original-order",
                           "type" : "Literal"
                        }, {
                           "localId" : "181",
                           "locator" : "204:52-204:65",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "reflex-order",
                           "type" : "Literal"
                        }, {
                           "localId" : "182",
                           "locator" : "204:68-204:81",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "filler-order",
                           "type" : "Literal"
                        }, {
                           "localId" : "183",
                           "locator" : "204:84-204:99",
                           "valueType" : "{urn:hl7-org:elm-types:r1}String",
                           "value" : "instance-order",
                           "type" : "Literal"
                        } ]
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "190",
            "locator" : "206:1-207:23",
            "name" : "All Medications",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "190",
                  "s" : [ {
                     "value" : [ "","define ","\"All Medications\"",":\n  " ]
                  }, {
                     "r" : "189",
                     "s" : [ {
                        "value" : [ "[","\"MedicationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "189",
               "locator" : "207:3-207:23",
               "dataType" : "{http://hl7.org/fhir}Medication",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "192",
            "locator" : "215:1-216:42",
            "name" : "Pediatric BMI for Age",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Pediatric BMI for Age](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-bmi-for-age.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age"
               } ],
               "s" : {
                  "r" : "192",
                  "s" : [ {
                     "value" : [ "// Pediatric BMI for Age\n\n/*\n@comment: [Pediatric BMI for Age](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-bmi-for-age.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age\n*/\n","define ","\"Pediatric BMI for Age\"",":\n  " ]
                  }, {
                     "r" : "191",
                     "s" : [ {
                        "value" : [ "[","\"PediatricBMIforAgeObservationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "191",
               "locator" : "216:3-216:42",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "194",
            "locator" : "235:1-236:48",
            "name" : "Pediatric Weight for Height",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Pediatric Head Circumference Percentile](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-head-occipital-frontal-circumference-percentile.html)"
               }, {
                  "name" : "profile",
                  "value" : "\"All Pediatric Head Circumference Percentile Measurements\":"
               }, {
                  "name" : "comment",
                  "value" : "[Pediatric Weight for Height](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-weight-for-height.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height"
               } ],
               "s" : {
                  "r" : "194",
                  "s" : [ {
                     "value" : [ "// Pediatric Head Circumference Percentile\n\n/*\n@comment: [Pediatric Head Circumference Percentile](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-head-occipital-frontal-circumference-percentile.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/head-occipital-frontal-circumference-percentile\n*/\n//define \"All Pediatric Head Circumference Percentile Measurements\":\n  //TODO - profile not in modelinfo\n  //UsCorePediatricHeadOccipitalFrontalCircumferencePercentileProfile\n\n\n// Pediatric Weight for Height\n\n/*\n@comment: [Pediatric Weight for Height](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-pediatric-weight-for-height.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height\n*/\n","define ","\"Pediatric Weight for Height\"",":\n  " ]
                  }, {
                     "r" : "193",
                     "s" : [ {
                        "value" : [ "[","\"PediatricWeightForHeightObservationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "193",
               "locator" : "236:3-236:48",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "206",
            "locator" : "244:1-246:78",
            "name" : "All Procedures",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Procedure](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-procedure.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure"
               } ],
               "s" : {
                  "r" : "206",
                  "s" : [ {
                     "value" : [ "// Procedure\n\n/*\n@comment: [Procedure](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-procedure.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure\n*/\n","define ","\"All Procedures\"",":\n  " ]
                  }, {
                     "r" : "205",
                     "s" : [ {
                        "s" : [ {
                           "r" : "196",
                           "s" : [ {
                              "r" : "195",
                              "s" : [ {
                                 "r" : "195",
                                 "s" : [ {
                                    "value" : [ "[","\"ProcedureProfile\"","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","P" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "204",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "204",
                           "s" : [ {
                              "r" : "198",
                              "s" : [ {
                                 "r" : "197",
                                 "s" : [ {
                                    "value" : [ "P" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "198",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " in " ]
                           }, {
                              "r" : "203",
                              "s" : [ {
                                 "value" : [ "{ " ]
                              }, {
                                 "r" : "199",
                                 "s" : [ {
                                    "value" : [ "'preparation'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "200",
                                 "s" : [ {
                                    "value" : [ "'in-progress'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "201",
                                 "s" : [ {
                                    "value" : [ "'on-hold'" ]
                                 } ]
                              }, {
                                 "value" : [ ", " ]
                              }, {
                                 "r" : "202",
                                 "s" : [ {
                                    "value" : [ "'completed'" ]
                                 } ]
                              }, {
                                 "value" : [ " }" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "205",
               "locator" : "245:3-246:78",
               "type" : "Query",
               "source" : [ {
                  "localId" : "196",
                  "locator" : "245:3-245:24",
                  "alias" : "P",
                  "expression" : {
                     "localId" : "195",
                     "locator" : "245:3-245:22",
                     "dataType" : "{http://hl7.org/fhir}Procedure",
                     "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "204",
                  "locator" : "246:5-246:78",
                  "type" : "In",
                  "operand" : [ {
                     "localId" : "198",
                     "locator" : "246:11-246:18",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "P",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "203",
                     "locator" : "246:23-246:78",
                     "type" : "List",
                     "element" : [ {
                        "localId" : "199",
                        "locator" : "246:25-246:37",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "preparation",
                        "type" : "Literal"
                     }, {
                        "localId" : "200",
                        "locator" : "246:40-246:52",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "in-progress",
                        "type" : "Literal"
                     }, {
                        "localId" : "201",
                        "locator" : "246:55-246:63",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "on-hold",
                        "type" : "Literal"
                     }, {
                        "localId" : "202",
                        "locator" : "246:66-246:76",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "completed",
                        "type" : "Literal"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "214",
            "locator" : "248:1-250:32",
            "name" : "All Performed Procedures",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "214",
                  "s" : [ {
                     "value" : [ "","define ","\"All Performed Procedures\"",":\n  " ]
                  }, {
                     "r" : "213",
                     "s" : [ {
                        "s" : [ {
                           "r" : "208",
                           "s" : [ {
                              "r" : "207",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "\"All Procedures\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","P" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "212",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "212",
                           "s" : [ {
                              "r" : "210",
                              "s" : [ {
                                 "r" : "209",
                                 "s" : [ {
                                    "value" : [ "P" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "210",
                                 "s" : [ {
                                    "value" : [ "status" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "211",
                              "s" : [ {
                                 "value" : [ "'completed'" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "213",
               "locator" : "249:3-250:32",
               "type" : "Query",
               "source" : [ {
                  "localId" : "208",
                  "locator" : "249:3-249:20",
                  "alias" : "P",
                  "expression" : {
                     "localId" : "207",
                     "locator" : "249:3-249:18",
                     "name" : "All Procedures",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "212",
                  "locator" : "250:5-250:32",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "210",
                     "locator" : "250:11-250:18",
                     "path" : "value",
                     "type" : "Property",
                     "source" : {
                        "path" : "status",
                        "scope" : "P",
                        "type" : "Property"
                     }
                  }, {
                     "localId" : "211",
                     "locator" : "250:22-250:32",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "completed",
                     "type" : "Literal"
                  } ]
               }
            }
         }, {
            "localId" : "216",
            "locator" : "258:1-259:26",
            "name" : "Pulse Oximetry",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Pulse Oximetry](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-pulse-oximetry.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry"
               } ],
               "s" : {
                  "r" : "216",
                  "s" : [ {
                     "value" : [ "// Pulse Oximetry\n\n/*\n@comment: [Pulse Oximetry](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-pulse-oximetry.html)\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry\n*/\n","define ","\"Pulse Oximetry\"",":\n  " ]
                  }, {
                     "r" : "215",
                     "s" : [ {
                        "value" : [ "[","\"PulseOximetryProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "215",
               "locator" : "259:3-259:26",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "218",
            "locator" : "270:1-271:26",
            "name" : "Smoking Status",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns all smoking status observations"
               }, {
                  "name" : "comment",
                  "value" : "This definition returns all smoking status observations conforming to the US Core 3.1.1\n[Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)\nprofile."
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus"
               } ],
               "s" : {
                  "r" : "218",
                  "s" : [ {
                     "value" : [ "// Smoking Status\n\n/*\n@description: Returns all smoking status observations\n@comment: This definition returns all smoking status observations conforming to the US Core 3.1.1\n[Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)\nprofile.\n@profile: http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus\n*/\n","define ","\"Smoking Status\"",":\n  " ]
                  }, {
                     "r" : "217",
                     "s" : [ {
                        "value" : [ "[","\"SmokingStatusProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "217",
               "locator" : "271:3-271:26",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "230",
            "locator" : "279:1-284:3",
            "name" : "Most Recent Smoking Status",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "description",
                  "value" : "Returns the most recent smoking status"
               }, {
                  "name" : "comment",
                  "value" : "This definition returns the most recent (by issued time) smoking status observation conforming to the\nUS Core 3.1.1 [Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)\nprofile."
               } ],
               "s" : {
                  "r" : "230",
                  "s" : [ {
                     "value" : [ "/*\n@description: Returns the most recent smoking status\n@comment: This definition returns the most recent (by issued time) smoking status observation conforming to the\nUS Core 3.1.1 [Smoking Status](https://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-smokingstatus.html)\nprofile.\n*/\n","define ","\"Most Recent Smoking Status\"",":\n  " ]
                  }, {
                     "r" : "229",
                     "s" : [ {
                        "value" : [ "Last","(\n    " ]
                     }, {
                        "r" : "228",
                        "s" : [ {
                           "s" : [ {
                              "r" : "220",
                              "s" : [ {
                                 "r" : "219",
                                 "s" : [ {
                                    "s" : [ {
                                       "value" : [ "\"Smoking Status\"" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","SS" ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n        " ]
                        }, {
                           "r" : "224",
                           "s" : [ {
                              "value" : [ "where " ]
                           }, {
                              "r" : "224",
                              "s" : [ {
                                 "r" : "222",
                                 "s" : [ {
                                    "r" : "221",
                                    "s" : [ {
                                       "value" : [ "SS" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "222",
                                    "s" : [ {
                                       "value" : [ "status" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","="," " ]
                              }, {
                                 "r" : "223",
                                 "s" : [ {
                                    "value" : [ "'final'" ]
                                 } ]
                              } ]
                           } ]
                        }, {
                           "value" : [ "\n        " ]
                        }, {
                           "r" : "227",
                           "s" : [ {
                              "value" : [ "sort by " ]
                           }, {
                              "r" : "226",
                              "s" : [ {
                                 "r" : "225",
                                 "s" : [ {
                                    "value" : [ "issued" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n  )" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "229",
               "locator" : "280:3-284:3",
               "type" : "Last",
               "source" : {
                  "localId" : "228",
                  "locator" : "281:5-283:22",
                  "type" : "Query",
                  "source" : [ {
                     "localId" : "220",
                     "locator" : "281:5-281:23",
                     "alias" : "SS",
                     "expression" : {
                        "localId" : "219",
                        "locator" : "281:5-281:20",
                        "name" : "Smoking Status",
                        "type" : "ExpressionRef"
                     }
                  } ],
                  "relationship" : [ ],
                  "where" : {
                     "localId" : "224",
                     "locator" : "282:9-282:33",
                     "type" : "Equal",
                     "operand" : [ {
                        "localId" : "222",
                        "locator" : "282:15-282:23",
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "path" : "status",
                           "scope" : "SS",
                           "type" : "Property"
                        }
                     }, {
                        "localId" : "223",
                        "locator" : "282:27-282:33",
                        "valueType" : "{urn:hl7-org:elm-types:r1}String",
                        "value" : "final",
                        "type" : "Literal"
                     } ]
                  },
                  "sort" : {
                     "localId" : "227",
                     "locator" : "283:9-283:22",
                     "by" : [ {
                        "localId" : "226",
                        "locator" : "283:17-283:22",
                        "direction" : "asc",
                        "type" : "ByExpression",
                        "expression" : {
                           "localId" : "225",
                           "locator" : "283:17-283:22",
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "issued",
                              "type" : "IdentifierRef"
                           }
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "232",
            "locator" : "292:1-293:29",
            "name" : "All Vital Signs Panels",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Vital Signs Panel](http://hl7.org/fhir/R4/vitalspanel.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/vitalspanel"
               } ],
               "s" : {
                  "r" : "232",
                  "s" : [ {
                     "value" : [ "// Vital Signs Panel\n\n/*\n@comment: [Vital Signs Panel](http://hl7.org/fhir/R4/vitalspanel.html)\n@profile: http://hl7.org/fhir/StructureDefinition/vitalspanel\n*/\n","define ","\"All Vital Signs Panels\"",":\n  " ]
                  }, {
                     "r" : "231",
                     "s" : [ {
                        "value" : [ "[","\"observation-vitalspanel\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "231",
               "locator" : "293:3-293:29",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/vitalspanel",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "234",
            "locator" : "301:1-302:26",
            "name" : "All Respiratory Rate Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Respiratory Rate](http://hl7.org/fhir/R4/resprate.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/resprate"
               } ],
               "s" : {
                  "r" : "234",
                  "s" : [ {
                     "value" : [ "// Respiratory Rate\n\n/*\n@comment: [Respiratory Rate](http://hl7.org/fhir/R4/resprate.html)\n@profile: http://hl7.org/fhir/StructureDefinition/resprate\n*/\n","define ","\"All Respiratory Rate Measurements\"",":\n  " ]
                  }, {
                     "r" : "233",
                     "s" : [ {
                        "value" : [ "[","\"observation-resprate\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "233",
               "locator" : "302:3-302:26",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/resprate",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "236",
            "locator" : "310:1-311:27",
            "name" : "All Heart Rate Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Heart Rate](http://hl7.org/fhir/R4/heartrate.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/heartrate"
               } ],
               "s" : {
                  "r" : "236",
                  "s" : [ {
                     "value" : [ "// Heart Rate\n\n/*\n@comment: [Heart Rate](http://hl7.org/fhir/R4/heartrate.html)\n@profile:http://hl7.org/fhir/StructureDefinition/heartrate\n*/\n","define ","\"All Heart Rate Measurements\"",":\n  " ]
                  }, {
                     "r" : "235",
                     "s" : [ {
                        "value" : [ "[","\"observation-heartrate\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "235",
               "locator" : "311:3-311:27",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/heartrate",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "238",
            "locator" : "319:1-320:27",
            "name" : "All Oxygen Saturation Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Oxygen Saturation](http://hl7.org/fhir/R4/oxygensat.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/oxygensat"
               } ],
               "s" : {
                  "r" : "238",
                  "s" : [ {
                     "value" : [ "// Oxygen Saturation\n\n/*\n@comment: [Oxygen Saturation](http://hl7.org/fhir/R4/oxygensat.html)\n@profile: http://hl7.org/fhir/StructureDefinition/oxygensat\n*/\n","define ","\"All Oxygen Saturation Measurements\"",":\n  " ]
                  }, {
                     "r" : "237",
                     "s" : [ {
                        "value" : [ "[","\"observation-oxygensat\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "237",
               "locator" : "320:3-320:27",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/oxygensat",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "240",
            "locator" : "328:1-329:26",
            "name" : "All Body Temperature Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Body Temperature](http://hl7.org/fhir/R4/bodytemp.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/bodytemp"
               } ],
               "s" : {
                  "r" : "240",
                  "s" : [ {
                     "value" : [ "// Body Temperature\n\n/*\n@comment: [Body Temperature](http://hl7.org/fhir/R4/bodytemp.html)\n@profile: http://hl7.org/fhir/StructureDefinition/bodytemp\n*/\n","define ","\"All Body Temperature Measurements\"",":\n  " ]
                  }, {
                     "r" : "239",
                     "s" : [ {
                        "value" : [ "[","\"observation-bodytemp\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "239",
               "locator" : "329:3-329:26",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodytemp",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "242",
            "locator" : "337:1-338:28",
            "name" : "All Body Height Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Body Height](http://hl7.org/fhir/R4/bodyheight.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/bodyheight"
               } ],
               "s" : {
                  "r" : "242",
                  "s" : [ {
                     "value" : [ "// Body Height\n\n/*\n@comment: [Body Height](http://hl7.org/fhir/R4/bodyheight.html)\n@profile: http://hl7.org/fhir/StructureDefinition/bodyheight\n*/\n","define ","\"All Body Height Measurements\"",":\n  " ]
                  }, {
                     "r" : "241",
                     "s" : [ {
                        "value" : [ "[","\"observation-bodyheight\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "241",
               "locator" : "338:3-338:28",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodyheight",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "244",
            "locator" : "346:1-347:28",
            "name" : "All Head Circumference Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Head Circumference](http://hl7.org/fhir/R4/headcircum.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/headcircum"
               } ],
               "s" : {
                  "r" : "244",
                  "s" : [ {
                     "value" : [ "// Head Circumference\n\n/*\n@comment: [Head Circumference](http://hl7.org/fhir/R4/headcircum.html)\n@profile: http://hl7.org/fhir/StructureDefinition/headcircum\n*/\n","define ","\"All Head Circumference Measurements\"",":\n  " ]
                  }, {
                     "r" : "243",
                     "s" : [ {
                        "value" : [ "[","\"observation-headcircum\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "243",
               "locator" : "347:3-347:28",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/headcircum",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "246",
            "locator" : "355:1-356:28",
            "name" : "All Body Weight Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Body Weight](http://hl7.org/fhir/R4/bodyweight.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/bodyweight"
               } ],
               "s" : {
                  "r" : "246",
                  "s" : [ {
                     "value" : [ "// Body Weight\n\n/*\n@comment: [Body Weight](http://hl7.org/fhir/R4/bodyweight.html)\n@profile: http://hl7.org/fhir/StructureDefinition/bodyweight\n*/\n","define ","\"All Body Weight Measurements\"",":\n  " ]
                  }, {
                     "r" : "245",
                     "s" : [ {
                        "value" : [ "[","\"observation-bodyweight\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "245",
               "locator" : "356:3-356:28",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodyweight",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "248",
            "locator" : "364:1-365:21",
            "name" : "All Body Mass Index Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Body Mass Index](http://hl7.org/fhir/R4/bmi.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/bmi"
               } ],
               "s" : {
                  "r" : "248",
                  "s" : [ {
                     "value" : [ "// Body Mass Index\n\n/*\n@comment: [Body Mass Index](http://hl7.org/fhir/R4/bmi.html)\n@profile: http://hl7.org/fhir/StructureDefinition/bmi\n*/\n","define ","\"All Body Mass Index Measurements\"",":\n  " ]
                  }, {
                     "r" : "247",
                     "s" : [ {
                        "value" : [ "[","\"observation-bmi\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "247",
               "locator" : "365:3-365:21",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bmi",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "250",
            "locator" : "373:1-374:20",
            "name" : "All Blood Pressure Measurements",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "t" : [ {
                  "name" : "comment",
                  "value" : "[Blood Pressure](http://hl7.org/fhir/R4/bp.html)"
               }, {
                  "name" : "profile",
                  "value" : "http://hl7.org/fhir/StructureDefinition/bp"
               } ],
               "s" : {
                  "r" : "250",
                  "s" : [ {
                     "value" : [ "// Blood Pressure\n\n/*\n@comment: [Blood Pressure](http://hl7.org/fhir/R4/bp.html)\n@profile: http://hl7.org/fhir/StructureDefinition/bp\n*/\n","define ","\"All Blood Pressure Measurements\"",":\n  " ]
                  }, {
                     "r" : "249",
                     "s" : [ {
                        "value" : [ "[","\"observation-bp\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "249",
               "locator" : "374:3-374:20",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bp",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "254",
            "locator" : "377:1-378:52",
            "name" : "Systolic Blood Pressure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "254",
                  "s" : [ {
                     "value" : [ "// Systolic Blood Pressure\n","define ","\"Systolic Blood Pressure\"",":\n  " ]
                  }, {
                     "r" : "253",
                     "s" : [ {
                        "r" : "252",
                        "s" : [ {
                           "r" : "251",
                           "s" : [ {
                              "value" : [ "\"All Blood Pressure Measurements\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "252",
                           "s" : [ {
                              "value" : [ "SystolicBP" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "253",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "253",
               "locator" : "378:3-378:52",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "252",
                     "locator" : "378:3-378:46",
                     "type" : "Query",
                     "source" : [ {
                        "alias" : "$this",
                        "expression" : {
                           "localId" : "251",
                           "locator" : "378:3-378:35",
                           "name" : "All Blood Pressure Measurements",
                           "type" : "ExpressionRef"
                        }
                     } ],
                     "where" : {
                        "type" : "Not",
                        "operand" : {
                           "type" : "IsNull",
                           "operand" : {
                              "type" : "SingletonFrom",
                              "operand" : {
                                 "type" : "Query",
                                 "source" : [ {
                                    "alias" : "$this",
                                    "expression" : {
                                       "path" : "component",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 } ],
                                 "where" : {
                                    "type" : "And",
                                    "operand" : [ {
                                       "type" : "Equal",
                                       "operand" : [ {
                                          "name" : "ToString",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "system",
                                             "type" : "Property",
                                             "source" : {
                                                "type" : "First",
                                                "source" : {
                                                   "path" : "coding",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "code",
                                                      "scope" : "$this",
                                                      "type" : "Property"
                                                   }
                                                }
                                             }
                                          } ]
                                       }, {
                                          "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                          "value" : "http://loinc.org",
                                          "type" : "Literal"
                                       } ]
                                    }, {
                                       "type" : "Equal",
                                       "operand" : [ {
                                          "name" : "ToString",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "code",
                                             "type" : "Property",
                                             "source" : {
                                                "type" : "First",
                                                "source" : {
                                                   "path" : "coding",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "code",
                                                      "scope" : "$this",
                                                      "type" : "Property"
                                                   }
                                                }
                                             }
                                          } ]
                                       }, {
                                          "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                          "value" : "8480-6",
                                          "type" : "Literal"
                                       } ]
                                    } ]
                                 }
                              }
                           }
                        }
                     },
                     "return" : {
                        "distinct" : false,
                        "expression" : {
                           "type" : "SingletonFrom",
                           "operand" : {
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "path" : "component",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              } ],
                              "where" : {
                                 "type" : "And",
                                 "operand" : [ {
                                    "type" : "Equal",
                                    "operand" : [ {
                                       "name" : "ToString",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "system",
                                          "type" : "Property",
                                          "source" : {
                                             "type" : "First",
                                             "source" : {
                                                "path" : "coding",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "code",
                                                   "scope" : "$this",
                                                   "type" : "Property"
                                                }
                                             }
                                          }
                                       } ]
                                    }, {
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "http://loinc.org",
                                       "type" : "Literal"
                                    } ]
                                 }, {
                                    "type" : "Equal",
                                    "operand" : [ {
                                       "name" : "ToString",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "code",
                                          "type" : "Property",
                                          "source" : {
                                             "type" : "First",
                                             "source" : {
                                                "path" : "coding",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "code",
                                                   "scope" : "$this",
                                                   "type" : "Property"
                                                }
                                             }
                                          }
                                       } ]
                                    }, {
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "8480-6",
                                       "type" : "Literal"
                                    } ]
                                 } ]
                              }
                           }
                        }
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "name" : "ToValue",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        } ]
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "name" : "ToValue",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     } ]
                  }
               }
            }
         }, {
            "localId" : "258",
            "locator" : "381:1-382:53",
            "name" : "Diastolic Blood Pressure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "258",
                  "s" : [ {
                     "value" : [ "// Diastolic Blood Pressure\n","define ","\"Diastolic Blood Pressure\"",":\n  " ]
                  }, {
                     "r" : "257",
                     "s" : [ {
                        "r" : "256",
                        "s" : [ {
                           "r" : "255",
                           "s" : [ {
                              "value" : [ "\"All Blood Pressure Measurements\"" ]
                           } ]
                        }, {
                           "value" : [ "." ]
                        }, {
                           "r" : "256",
                           "s" : [ {
                              "value" : [ "DiastolicBP" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "." ]
                     }, {
                        "r" : "257",
                        "s" : [ {
                           "value" : [ "value" ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "257",
               "locator" : "382:3-382:53",
               "type" : "Query",
               "source" : [ {
                  "alias" : "$this",
                  "expression" : {
                     "localId" : "256",
                     "locator" : "382:3-382:47",
                     "type" : "Query",
                     "source" : [ {
                        "alias" : "$this",
                        "expression" : {
                           "localId" : "255",
                           "locator" : "382:3-382:35",
                           "name" : "All Blood Pressure Measurements",
                           "type" : "ExpressionRef"
                        }
                     } ],
                     "where" : {
                        "type" : "Not",
                        "operand" : {
                           "type" : "IsNull",
                           "operand" : {
                              "type" : "SingletonFrom",
                              "operand" : {
                                 "type" : "Query",
                                 "source" : [ {
                                    "alias" : "$this",
                                    "expression" : {
                                       "path" : "component",
                                       "type" : "Property",
                                       "source" : {
                                          "name" : "$this",
                                          "type" : "AliasRef"
                                       }
                                    }
                                 } ],
                                 "where" : {
                                    "type" : "And",
                                    "operand" : [ {
                                       "type" : "Equal",
                                       "operand" : [ {
                                          "name" : "ToString",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "system",
                                             "type" : "Property",
                                             "source" : {
                                                "type" : "First",
                                                "source" : {
                                                   "path" : "coding",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "code",
                                                      "scope" : "$this",
                                                      "type" : "Property"
                                                   }
                                                }
                                             }
                                          } ]
                                       }, {
                                          "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                          "value" : "http://loinc.org",
                                          "type" : "Literal"
                                       } ]
                                    }, {
                                       "type" : "Equal",
                                       "operand" : [ {
                                          "name" : "ToString",
                                          "libraryName" : "FHIRHelpers",
                                          "type" : "FunctionRef",
                                          "operand" : [ {
                                             "path" : "code",
                                             "type" : "Property",
                                             "source" : {
                                                "type" : "First",
                                                "source" : {
                                                   "path" : "coding",
                                                   "type" : "Property",
                                                   "source" : {
                                                      "path" : "code",
                                                      "scope" : "$this",
                                                      "type" : "Property"
                                                   }
                                                }
                                             }
                                          } ]
                                       }, {
                                          "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                          "value" : "8462-4",
                                          "type" : "Literal"
                                       } ]
                                    } ]
                                 }
                              }
                           }
                        }
                     },
                     "return" : {
                        "distinct" : false,
                        "expression" : {
                           "type" : "SingletonFrom",
                           "operand" : {
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "path" : "component",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              } ],
                              "where" : {
                                 "type" : "And",
                                 "operand" : [ {
                                    "type" : "Equal",
                                    "operand" : [ {
                                       "name" : "ToString",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "system",
                                          "type" : "Property",
                                          "source" : {
                                             "type" : "First",
                                             "source" : {
                                                "path" : "coding",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "code",
                                                   "scope" : "$this",
                                                   "type" : "Property"
                                                }
                                             }
                                          }
                                       } ]
                                    }, {
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "http://loinc.org",
                                       "type" : "Literal"
                                    } ]
                                 }, {
                                    "type" : "Equal",
                                    "operand" : [ {
                                       "name" : "ToString",
                                       "libraryName" : "FHIRHelpers",
                                       "type" : "FunctionRef",
                                       "operand" : [ {
                                          "path" : "code",
                                          "type" : "Property",
                                          "source" : {
                                             "type" : "First",
                                             "source" : {
                                                "path" : "coding",
                                                "type" : "Property",
                                                "source" : {
                                                   "path" : "code",
                                                   "scope" : "$this",
                                                   "type" : "Property"
                                                }
                                             }
                                          }
                                       } ]
                                    }, {
                                       "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                       "value" : "8462-4",
                                       "type" : "Literal"
                                    } ]
                                 } ]
                              }
                           }
                        }
                     }
                  }
               } ],
               "where" : {
                  "type" : "Not",
                  "operand" : {
                     "type" : "IsNull",
                     "operand" : {
                        "name" : "ToValue",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "value",
                           "type" : "Property",
                           "source" : {
                              "name" : "$this",
                              "type" : "AliasRef"
                           }
                        } ]
                     }
                  }
               },
               "return" : {
                  "distinct" : false,
                  "expression" : {
                     "name" : "ToValue",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "path" : "value",
                        "type" : "Property",
                        "source" : {
                           "name" : "$this",
                           "type" : "AliasRef"
                        }
                     } ]
                  }
               }
            }
         } ]
      }
   }
}" + } ] +} \ No newline at end of file diff --git a/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreTests.json b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreTests.json new file mode 100644 index 000000000..176376c26 --- /dev/null +++ b/tooling/src/test/resources/NewRefreshIG/input/resources/library/library-USCoreTests.json @@ -0,0 +1,520 @@ +{ + "resourceType": "Library", + "id": "USCoreTests", + "extension": [ { + "url": "http://hl7.org/fhir/us/cqfmeasures/StructureDefinition/cqfm-softwaresystem", + "valueReference": { + "reference": "Device/cqf-tooling" + } + } ], + "url": "http://fhir.org/guides/cqf/us/common/Library/USCoreTests", + "version": "0.1.0", + "name": "USCoreTests", + "relatedArtifact": [ { + "type": "depends-on", + "display": "USCore model information", + "resource": "http://hl7.org/fhir/Library/USCore-ModelInfo" + }, { + "type": "depends-on", + "display": "Library FHIRHelpers", + "resource": "http://fhir.org/guides/cqf/us/common/Library/FHIRHelpers|4.1.000" + }, { + "type": "depends-on", + "display": "Code system Marital Status Codes", + "resource": "http://terminology.hl7.org/CodeSystem/v3-MaritalStatus" + }, { + "type": "depends-on", + "display": "Code system CDC Race and Ethnicity Codes", + "resource": "urn:oid:2.16.840.1.113883.6.238" + }, { + "type": "depends-on", + "display": "Value set Marital Status", + "resource": "http://hl7.org/fhir/ValueSet/marital-status" + } ], + "parameter": [ { + "name": "Patient", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "TestPatient", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestAllergyIntolerance", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestCarePlan", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestCareTeam", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestCondition", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestDiagnosticReport", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestDiagnosticReportNote", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestDocumentReference", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestEncounter", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestGoal", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestImmunization", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestImplantableDevice", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestObservation", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestLocation", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestMedication", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestMedicationRequest", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestOrganization", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestVitalsPanel", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestVitalsPanel2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestRespRate", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestRespRate2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestHeartRate", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestHeartRate2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestOxygenSat", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestOxygenSat2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBodyTemp", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBodyTemp2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBodyHeight", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBodyHeight2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestHeadCircum", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestHeadCircum2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBodyWeight", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBodyWeight2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBMI", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBMI2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBP", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestBP2", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestSmokingStatus", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestPulseOximetry", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestPediatricBMIForAge", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestPediatricWeightForHeight", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestPractitioner", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestPractitionerRole", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestProcedure", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestProvenance", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestPrimitives", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "TestChoice", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "TestSlices", + "use": "out", + "min": 0, + "max": "*", + "type": "Any" + }, { + "name": "TestSimpleExtensions", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "TestComplexExtensions", + "use": "out", + "min": 0, + "max": "1", + "type": "Any" + }, { + "name": "TestComplexFHIRHelpers", + "use": "out", + "min": 0, + "max": "*", + "type": "CodeableConcept" + } ], + "dataRequirement": [ { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ] + }, { + "type": "AllergyIntolerance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" ] + }, { + "type": "CarePlan", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-careplan" ] + }, { + "type": "CareTeam", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-careteam" ] + }, { + "type": "Condition", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" ] + }, { + "type": "DiagnosticReport", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab" ] + }, { + "type": "DiagnosticReport", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note" ] + }, { + "type": "DocumentReference", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-documentreference" ] + }, { + "type": "Encounter", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" ] + }, { + "type": "Goal", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-goal" ] + }, { + "type": "Immunization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization" ] + }, { + "type": "Device", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab" ] + }, { + "type": "Location", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-location" ] + }, { + "type": "Medication", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" ] + }, { + "type": "MedicationRequest", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest" ] + }, { + "type": "Organization", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/vitalspanel" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/vitalspanel" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/resprate" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/resprate" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/heartrate" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/heartrate" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/oxygensat" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/oxygensat" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodytemp" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodytemp" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyheight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyheight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/headcircum" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/headcircum" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyweight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bodyweight" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bmi" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bmi" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height" ] + }, { + "type": "Practitioner", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" ] + }, { + "type": "PractitionerRole", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitionerrole" ] + }, { + "type": "Procedure", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" ] + }, { + "type": "Provenance", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-provenance" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "gender", "gender.value", "active", "active.value", "birthDate", "birthDate.value", "maritalStatus" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "deceased" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/StructureDefinition/bp" ], + "mustSupport": [ "component" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "extension" ] + }, { + "type": "Patient", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" ], + "mustSupport": [ "extension" ] + }, { + "type": "Observation", + "profile": [ "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age" ], + "mustSupport": [ "category" ] + } ], + "content": [ { + "contentType": "text/cql", + "data": "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" + }, { + "contentType": "application/elm+xml", + "data": "<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="urn:hl7-org:elm:r1" xmlns:t="urn:hl7-org:elm-types:r1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:fhir="http://hl7.org/fhir" xmlns:qdm43="urn:healthit-gov:qdm:v4_3" xmlns:qdm53="urn:healthit-gov:qdm:v5_3" xmlns:a="urn:hl7-org:cql-annotations:r1">
   <annotation translatorVersion="2.7.0" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion" xsi:type="a:CqlToElmInfo"/>
   <annotation xsi:type="a:Annotation">
      <a:t name="description" value="This is a testing library used to validate capability of the CQL-to-ELM translator&#xa;using the US Core model info. It is not intended as"/>
      <a:s r="185">
         <a:s>/*
@description: This is a testing library used to validate capability of the CQL-to-ELM translator
using the US Core model info. It is not intended as
*/
library USCoreTests version '0.1.0'</a:s>
      </a:s>
   </annotation>
   <identifier id="USCoreTests" system="http://fhir.org/guides/cqf/us/common" version="0.1.0"/>
   <schemaIdentifier id="urn:hl7-org:elm" version="r1"/>
   <usings>
      <def localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <def localId="1" locator="7:1-7:28" localIdentifier="USCore" uri="http://hl7.org/fhir">
         <annotation xsi:type="a:Annotation">
            <a:s r="1">
               <a:s>using </a:s>
               <a:s>
                  <a:s>USCore</a:s>
               </a:s>
               <a:s> version '3.1.1'</a:s>
            </a:s>
         </annotation>
      </def>
   </usings>
   <includes>
      <def localId="2" locator="9:1-9:37" localIdentifier="FHIRHelpers" path="http://fhir.org/guides/cqf/us/common/FHIRHelpers" version="4.1.000">
         <annotation xsi:type="a:Annotation">
            <a:s r="2">
               <a:s>include </a:s>
               <a:s>
                  <a:s>FHIRHelpers</a:s>
               </a:s>
               <a:s> version '4.1.000'</a:s>
            </a:s>
         </annotation>
      </def>
   </includes>
   <codeSystems>
      <def localId="3" locator="11:1-11:91" name="Marital Status Codes" id="http://terminology.hl7.org/CodeSystem/v3-MaritalStatus" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="3">
               <a:s>codesystem &quot;Marital Status Codes&quot;: 'http://terminology.hl7.org/CodeSystem/v3-MaritalStatus'</a:s>
            </a:s>
         </annotation>
      </def>
      <def localId="4" locator="12:1-12:76" name="CDC Race and Ethnicity Codes" id="urn:oid:2.16.840.1.113883.6.238" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="4">
               <a:s>codesystem &quot;CDC Race and Ethnicity Codes&quot;: 'urn:oid:2.16.840.1.113883.6.238'</a:s>
            </a:s>
         </annotation>
      </def>
   </codeSystems>
   <valueSets>
      <def localId="5" locator="14:1-14:72" name="Marital Status" id="http://hl7.org/fhir/ValueSet/marital-status" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="5">
               <a:s>valueset &quot;Marital Status&quot;: 'http://hl7.org/fhir/ValueSet/marital-status'</a:s>
            </a:s>
         </annotation>
      </def>
   </valueSets>
   <codes>
      <def localId="7" locator="16:1-16:64" name="Marital Status - Married" id="M" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="7">
               <a:s>code &quot;Marital Status - Married&quot;: 'M' from </a:s>
               <a:s r="6">
                  <a:s>&quot;Marital Status Codes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="6" locator="16:43-16:64" name="Marital Status Codes"/>
      </def>
      <def localId="9" locator="17:1-17:85" name="American Indian or Alaska Native" id="1002-5" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="9">
               <a:s>code &quot;American Indian or Alaska Native&quot;: '1002-5' from </a:s>
               <a:s r="8">
                  <a:s>&quot;CDC Race and Ethnicity Codes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="8" locator="17:56-17:85" name="CDC Race and Ethnicity Codes"/>
      </def>
      <def localId="11" locator="18:1-18:66" name="Alaska Native" id="1735-0" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="11">
               <a:s>code &quot;Alaska Native&quot;: '1735-0' from </a:s>
               <a:s r="10">
                  <a:s>&quot;CDC Race and Ethnicity Codes&quot;</a:s>
               </a:s>
            </a:s>
         </annotation>
         <codeSystem localId="10" locator="18:37-18:66" name="CDC Race and Ethnicity Codes"/>
      </def>
   </codes>
   <contexts>
      <def locator="20:1-20:15" name="Patient"/>
   </contexts>
   <statements>
      <def locator="20:1-20:15" name="Patient" context="Patient">
         <expression xsi:type="SingletonFrom">
            <operand locator="20:1-20:15" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" xsi:type="Retrieve"/>
         </expression>
      </def>
      <def localId="13" locator="22:1-22:38" name="TestPatient" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="13">
               <a:s>define TestPatient: </a:s>
               <a:s r="12">
                  <a:s>[&quot;PatientProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="12" locator="22:21-22:38" dataType="fhir:Patient" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient" xsi:type="Retrieve"/>
      </def>
      <def localId="15" locator="23:1-23:53" name="TestAllergyIntolerance" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="15">
               <a:s>define TestAllergyIntolerance: </a:s>
               <a:s r="14">
                  <a:s>[&quot;AllergyIntolerance&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="14" locator="23:32-23:53" dataType="fhir:AllergyIntolerance" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance" xsi:type="Retrieve"/>
      </def>
      <def localId="17" locator="24:1-24:40" name="TestCarePlan" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="17">
               <a:s>define TestCarePlan: </a:s>
               <a:s r="16">
                  <a:s>[&quot;CarePlanProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="16" locator="24:22-24:40" dataType="fhir:CarePlan" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-careplan" xsi:type="Retrieve"/>
      </def>
      <def localId="19" locator="25:1-25:33" name="TestCareTeam" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="19">
               <a:s>define TestCareTeam: </a:s>
               <a:s r="18">
                  <a:s>[&quot;CareTeam&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="18" locator="25:22-25:33" dataType="fhir:CareTeam" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-careteam" xsi:type="Retrieve"/>
      </def>
      <def localId="21" locator="26:1-26:35" name="TestCondition" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="21">
               <a:s>define TestCondition: </a:s>
               <a:s r="20">
                  <a:s>[&quot;Condition&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="20" locator="26:23-26:35" dataType="fhir:Condition" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition" xsi:type="Retrieve"/>
      </def>
      <def localId="23" locator="27:1-27:75" name="TestDiagnosticReport" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="23">
               <a:s>define TestDiagnosticReport: </a:s>
               <a:s r="22">
                  <a:s>[&quot;DiagnosticReportProfileLaboratoryReporting&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="22" locator="27:30-27:75" dataType="fhir:DiagnosticReport" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab" xsi:type="Retrieve"/>
      </def>
      <def localId="25" locator="28:1-28:72" name="TestDiagnosticReportNote" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="25">
               <a:s>define TestDiagnosticReportNote: </a:s>
               <a:s r="24">
                  <a:s>[&quot;DiagnosticReportProfileNoteExchange&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="24" locator="28:34-28:72" dataType="fhir:DiagnosticReport" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note" xsi:type="Retrieve"/>
      </def>
      <def localId="27" locator="29:1-29:58" name="TestDocumentReference" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="27">
               <a:s>define TestDocumentReference: </a:s>
               <a:s r="26">
                  <a:s>[&quot;DocumentReferenceProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="26" locator="29:31-29:58" dataType="fhir:DocumentReference" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-documentreference" xsi:type="Retrieve"/>
      </def>
      <def localId="29" locator="30:1-30:42" name="TestEncounter" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="29">
               <a:s>define TestEncounter: </a:s>
               <a:s r="28">
                  <a:s>[&quot;EncounterProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="28" locator="30:23-30:42" dataType="fhir:Encounter" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter" xsi:type="Retrieve"/>
      </def>
      <def localId="31" locator="31:1-31:32" name="TestGoal" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="31">
               <a:s>define TestGoal: </a:s>
               <a:s r="30">
                  <a:s>[&quot;GoalProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="30" locator="31:18-31:32" dataType="fhir:Goal" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-goal" xsi:type="Retrieve"/>
      </def>
      <def localId="33" locator="32:1-32:48" name="TestImmunization" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="33">
               <a:s>define TestImmunization: </a:s>
               <a:s r="32">
                  <a:s>[&quot;ImmunizationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="32" locator="32:26-32:48" dataType="fhir:Immunization" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization" xsi:type="Retrieve"/>
      </def>
      <def localId="35" locator="33:1-33:58" name="TestImplantableDevice" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="35">
               <a:s>define TestImplantableDevice: </a:s>
               <a:s r="34">
                  <a:s>[&quot;ImplantableDeviceProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="34" locator="33:31-33:58" dataType="fhir:Device" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device" xsi:type="Retrieve"/>
      </def>
      <def localId="37" locator="34:1-34:62" name="TestObservation" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="37">
               <a:s>define TestObservation: </a:s>
               <a:s r="36">
                  <a:s>[&quot;LaboratoryResultObservationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="36" locator="34:25-34:62" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab" xsi:type="Retrieve"/>
      </def>
      <def localId="39" locator="35:1-35:33" name="TestLocation" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="39">
               <a:s>define TestLocation: </a:s>
               <a:s r="38">
                  <a:s>[&quot;Location&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="38" locator="35:22-35:33" dataType="fhir:Location" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-location" xsi:type="Retrieve"/>
      </def>
      <def localId="41" locator="36:1-36:44" name="TestMedication" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="41">
               <a:s>define TestMedication: </a:s>
               <a:s r="40">
                  <a:s>[&quot;MedicationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="40" locator="36:24-36:44" dataType="fhir:Medication" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication" xsi:type="Retrieve"/>
      </def>
      <def localId="43" locator="37:1-37:58" name="TestMedicationRequest" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="43">
               <a:s>define TestMedicationRequest: </a:s>
               <a:s r="42">
                  <a:s>[&quot;MedicationRequestProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="42" locator="37:31-37:58" dataType="fhir:MedicationRequest" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest" xsi:type="Retrieve"/>
      </def>
      <def localId="45" locator="38:1-38:48" name="TestOrganization" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="45">
               <a:s>define TestOrganization: </a:s>
               <a:s r="44">
                  <a:s>[&quot;OrganizationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="44" locator="38:26-38:48" dataType="fhir:Organization" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization" xsi:type="Retrieve"/>
      </def>
      <def localId="47" locator="39:1-39:51" name="TestVitalsPanel" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="47">
               <a:s>define TestVitalsPanel: </a:s>
               <a:s r="46">
                  <a:s>[&quot;observation-vitalspanel&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="46" locator="39:25-39:51" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/vitalspanel" xsi:type="Retrieve"/>
      </def>
      <def localId="49" locator="40:1-40:66" name="TestVitalsPanel2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="49">
               <a:s>define TestVitalsPanel2: </a:s>
               <a:s r="48">
                  <a:s>[&quot;Observation Vital Signs Panel Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="48" locator="40:26-40:66" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/vitalspanel" xsi:type="Retrieve"/>
      </def>
      <def localId="51" locator="41:1-41:45" name="TestRespRate" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="51">
               <a:s>define TestRespRate: </a:s>
               <a:s r="50">
                  <a:s>[&quot;observation-resprate&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="50" locator="41:22-41:45" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/resprate" xsi:type="Retrieve"/>
      </def>
      <def localId="53" locator="42:1-42:62" name="TestRespRate2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="53">
               <a:s>define TestRespRate2: </a:s>
               <a:s r="52">
                  <a:s>[&quot;Observation Respiratory Rate Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="52" locator="42:23-42:62" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/resprate" xsi:type="Retrieve"/>
      </def>
      <def localId="55" locator="43:1-43:47" name="TestHeartRate" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="55">
               <a:s>define TestHeartRate: </a:s>
               <a:s r="54">
                  <a:s>[&quot;observation-heartrate&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="54" locator="43:23-43:47" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/heartrate" xsi:type="Retrieve"/>
      </def>
      <def localId="57" locator="44:1-44:57" name="TestHeartRate2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="57">
               <a:s>define TestHeartRate2: </a:s>
               <a:s r="56">
                  <a:s>[&quot;Observation Heart Rate Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="56" locator="44:24-44:57" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/heartrate" xsi:type="Retrieve"/>
      </def>
      <def localId="59" locator="45:1-45:47" name="TestOxygenSat" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="59">
               <a:s>define TestOxygenSat: </a:s>
               <a:s r="58">
                  <a:s>[&quot;observation-oxygensat&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="58" locator="45:23-45:47" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/oxygensat" xsi:type="Retrieve"/>
      </def>
      <def localId="61" locator="46:1-46:64" name="TestOxygenSat2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="61">
               <a:s>define TestOxygenSat2: </a:s>
               <a:s r="60">
                  <a:s>[&quot;Observation Oxygen Saturation Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="60" locator="46:24-46:64" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/oxygensat" xsi:type="Retrieve"/>
      </def>
      <def localId="63" locator="47:1-47:45" name="TestBodyTemp" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="63">
               <a:s>define TestBodyTemp: </a:s>
               <a:s r="62">
                  <a:s>[&quot;observation-bodytemp&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="62" locator="47:22-47:45" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodytemp" xsi:type="Retrieve"/>
      </def>
      <def localId="65" locator="48:1-48:62" name="TestBodyTemp2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="65">
               <a:s>define TestBodyTemp2: </a:s>
               <a:s r="64">
                  <a:s>[&quot;Observation Body Temperature Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="64" locator="48:23-48:62" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodytemp" xsi:type="Retrieve"/>
      </def>
      <def localId="67" locator="49:1-49:49" name="TestBodyHeight" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="67">
               <a:s>define TestBodyHeight: </a:s>
               <a:s r="66">
                  <a:s>[&quot;observation-bodyheight&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="66" locator="49:24-49:49" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodyheight" xsi:type="Retrieve"/>
      </def>
      <def localId="69" locator="50:1-50:59" name="TestBodyHeight2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="69">
               <a:s>define TestBodyHeight2: </a:s>
               <a:s r="68">
                  <a:s>[&quot;Observation Body Height Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="68" locator="50:25-50:59" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodyheight" xsi:type="Retrieve"/>
      </def>
      <def localId="71" locator="51:1-51:49" name="TestHeadCircum" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="71">
               <a:s>define TestHeadCircum: </a:s>
               <a:s r="70">
                  <a:s>[&quot;observation-headcircum&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="70" locator="51:24-51:49" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/headcircum" xsi:type="Retrieve"/>
      </def>
      <def localId="73" locator="52:1-52:66" name="TestHeadCircum2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="73">
               <a:s>define TestHeadCircum2: </a:s>
               <a:s r="72">
                  <a:s>[&quot;Observation Head Circumference Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="72" locator="52:25-52:66" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/headcircum" xsi:type="Retrieve"/>
      </def>
      <def localId="75" locator="53:1-53:49" name="TestBodyWeight" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="75">
               <a:s>define TestBodyWeight: </a:s>
               <a:s r="74">
                  <a:s>[&quot;observation-bodyweight&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="74" locator="53:24-53:49" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodyweight" xsi:type="Retrieve"/>
      </def>
      <def localId="77" locator="54:1-54:59" name="TestBodyWeight2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="77">
               <a:s>define TestBodyWeight2: </a:s>
               <a:s r="76">
                  <a:s>[&quot;Observation Body Weight Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="76" locator="54:25-54:59" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bodyweight" xsi:type="Retrieve"/>
      </def>
      <def localId="79" locator="55:1-55:35" name="TestBMI" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="79">
               <a:s>define TestBMI: </a:s>
               <a:s r="78">
                  <a:s>[&quot;observation-bmi&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="78" locator="55:17-55:35" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bmi" xsi:type="Retrieve"/>
      </def>
      <def localId="81" locator="56:1-56:56" name="TestBMI2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="81">
               <a:s>define TestBMI2: </a:s>
               <a:s r="80">
                  <a:s>[&quot;Observation Body Mass Index Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="80" locator="56:18-56:56" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bmi" xsi:type="Retrieve"/>
      </def>
      <def localId="83" locator="58:1-58:33" name="TestBP" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="83">
               <a:s>define TestBP: </a:s>
               <a:s r="82">
                  <a:s>[&quot;observation-bp&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="82" locator="58:16-58:33" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bp" xsi:type="Retrieve"/>
      </def>
      <def localId="85" locator="59:1-59:54" name="TestBP2" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="85">
               <a:s>define TestBP2: </a:s>
               <a:s r="84">
                  <a:s>[&quot;Observation Blood Pressure Profile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="84" locator="59:17-59:54" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bp" xsi:type="Retrieve"/>
      </def>
      <def localId="87" locator="60:1-60:50" name="TestSmokingStatus" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="87">
               <a:s>define TestSmokingStatus: </a:s>
               <a:s r="86">
                  <a:s>[&quot;SmokingStatusProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="86" locator="60:27-60:50" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus" xsi:type="Retrieve"/>
      </def>
      <def localId="89" locator="61:1-61:50" name="TestPulseOximetry" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="89">
               <a:s>define TestPulseOximetry: </a:s>
               <a:s r="88">
                  <a:s>[&quot;PulseOximetryProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="88" locator="61:27-61:50" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry" xsi:type="Retrieve"/>
      </def>
      <def localId="91" locator="62:1-62:71" name="TestPediatricBMIForAge" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="91">
               <a:s>define TestPediatricBMIForAge: </a:s>
               <a:s r="90">
                  <a:s>[&quot;PediatricBMIforAgeObservationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="90" locator="62:32-62:71" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age" xsi:type="Retrieve"/>
      </def>
      <def localId="93" locator="63:1-63:83" name="TestPediatricWeightForHeight" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="93">
               <a:s>define TestPediatricWeightForHeight: </a:s>
               <a:s r="92">
                  <a:s>[&quot;PediatricWeightForHeightObservationProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="92" locator="63:38-63:83" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height" xsi:type="Retrieve"/>
      </def>
      <def localId="95" locator="64:1-64:48" name="TestPractitioner" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="95">
               <a:s>define TestPractitioner: </a:s>
               <a:s r="94">
                  <a:s>[&quot;PractitionerProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="94" locator="64:26-64:48" dataType="fhir:Practitioner" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner" xsi:type="Retrieve"/>
      </def>
      <def localId="97" locator="65:1-65:56" name="TestPractitionerRole" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="97">
               <a:s>define TestPractitionerRole: </a:s>
               <a:s r="96">
                  <a:s>[&quot;PractitionerRoleProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="96" locator="65:30-65:56" dataType="fhir:PractitionerRole" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitionerrole" xsi:type="Retrieve"/>
      </def>
      <def localId="99" locator="66:1-66:42" name="TestProcedure" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="99">
               <a:s>define TestProcedure: </a:s>
               <a:s r="98">
                  <a:s>[&quot;ProcedureProfile&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="98" locator="66:23-66:42" dataType="fhir:Procedure" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure" xsi:type="Retrieve"/>
      </def>
      <def localId="101" locator="67:1-67:37" name="TestProvenance" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="101">
               <a:s>define TestProvenance: </a:s>
               <a:s r="100">
                  <a:s>[&quot;Provenance&quot;]</a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="100" locator="67:24-67:37" dataType="fhir:Provenance" templateId="http://hl7.org/fhir/us/core/StructureDefinition/us-core-provenance" xsi:type="Retrieve"/>
      </def>
      <def localId="128" locator="69:1-75:54" name="TestPrimitives" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="128">
               <a:s>define TestPrimitives:
  </a:s>
               <a:s r="127">
                  <a:s>
                     <a:s r="103">
                        <a:s r="102">
                           <a:s>
                              <a:s>Patient</a:s>
                           </a:s>
                        </a:s>
                        <a:s> P</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="126">
                     <a:s>where </a:s>
                     <a:s r="126">
                        <a:s r="121">
                           <a:s r="116">
                              <a:s r="111">
                                 <a:s r="107">
                                    <a:s r="105">
                                       <a:s r="104">
                                          <a:s>P</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="105">
                                          <a:s>gender</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> = </a:s>
                                    <a:s r="106">
                                       <a:s>'male'</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s>
      and </a:s>
                                 <a:s r="110">
                                    <a:s r="109">
                                       <a:s r="108">
                                          <a:s>P</a:s>
                                       </a:s>
                                       <a:s>.</a:s>
                                       <a:s r="109">
                                          <a:s>active</a:s>
                                       </a:s>
                                    </a:s>
                                    <a:s> is true</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>
      and </a:s>
                              <a:s r="115">
                                 <a:s r="113">
                                    <a:s r="112">
                                       <a:s>P</a:s>
                                    </a:s>
                                    <a:s>.</a:s>
                                    <a:s r="113">
                                       <a:s>birthDate</a:s>
                                    </a:s>
                                 </a:s>
                                 <a:s r="115"> before </a:s>
                                 <a:s r="114">
                                    <a:s>Today()</a:s>
                                 </a:s>
                              </a:s>
                           </a:s>
                           <a:s>
      and </a:s>
                           <a:s r="120">
                              <a:s r="118">
                                 <a:s r="117">
                                    <a:s>P</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="118">
                                    <a:s>maritalStatus</a:s>
                                 </a:s>
                              </a:s>
                              <a:s> in </a:s>
                              <a:s r="119">
                                 <a:s>&quot;Marital Status&quot;</a:s>
                              </a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="125">
                           <a:s r="123">
                              <a:s r="122">
                                 <a:s>P</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="123">
                                 <a:s>maritalStatus</a:s>
                              </a:s>
                           </a:s>
                           <a:s> ~ </a:s>
                           <a:s r="124">
                              <a:s>&quot;Marital Status - Married&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="127" locator="70:3-75:54" xsi:type="Query">
            <source localId="103" locator="70:3-70:11" alias="P">
               <expression localId="102" locator="70:3-70:9" name="Patient" xsi:type="ExpressionRef"/>
            </source>
            <where localId="126" locator="71:5-75:54" xsi:type="And">
               <operand localId="121" locator="71:11-74:45" xsi:type="And">
                  <operand localId="116" locator="71:11-73:36" xsi:type="And">
                     <operand localId="111" locator="71:11-72:26" xsi:type="And">
                        <operand localId="107" locator="71:11-71:27" xsi:type="Equal">
                           <operand localId="105" locator="71:11-71:18" path="value" xsi:type="Property">
                              <source path="gender" scope="P" xsi:type="Property"/>
                           </operand>
                           <operand localId="106" locator="71:22-71:27" valueType="t:String" value="male" xsi:type="Literal"/>
                        </operand>
                        <operand localId="110" locator="72:11-72:26" xsi:type="IsTrue">
                           <operand localId="109" locator="72:11-72:18" path="value" xsi:type="Property">
                              <source path="active" scope="P" xsi:type="Property"/>
                           </operand>
                        </operand>
                     </operand>
                     <operand localId="115" locator="73:11-73:36" xsi:type="Before">
                        <operand localId="113" locator="73:11-73:21" path="value" xsi:type="Property">
                           <source path="birthDate" scope="P" xsi:type="Property"/>
                        </operand>
                        <operand localId="114" locator="73:30-73:36" xsi:type="Today"/>
                     </operand>
                  </operand>
                  <operand localId="120" locator="74:11-74:45" xsi:type="InValueSet">
                     <code localId="118" locator="74:11-74:25" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="maritalStatus" scope="P" xsi:type="Property"/>
                     </code>
                     <valueset localId="119" locator="74:30-74:45" name="Marital Status" preserve="true"/>
                  </operand>
               </operand>
               <operand localId="125" locator="75:11-75:54" xsi:type="Equivalent">
                  <operand localId="123" locator="75:11-75:25" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                     <operand path="maritalStatus" scope="P" xsi:type="Property"/>
                  </operand>
                  <operand xsi:type="ToConcept">
                     <operand localId="124" locator="75:29-75:54" name="Marital Status - Married" xsi:type="CodeRef"/>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="140" locator="77:1-80:34" name="TestChoice" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="140">
               <a:s>define TestChoice:
  </a:s>
               <a:s r="139">
                  <a:s>
                     <a:s r="130">
                        <a:s r="129">
                           <a:s>
                              <a:s>Patient</a:s>
                           </a:s>
                        </a:s>
                        <a:s> P</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="138">
                     <a:s>where </a:s>
                     <a:s r="138">
                        <a:s r="133">
                           <a:s r="132">
                              <a:s r="131">
                                 <a:s>P</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="132">
                                 <a:s>deceased</a:s>
                              </a:s>
                           </a:s>
                           <a:s> is false</a:s>
                        </a:s>
                        <a:s>
      or </a:s>
                        <a:s r="137">
                           <a:s r="135">
                              <a:s r="134">
                                 <a:s>P</a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="135">
                                 <a:s>deceased</a:s>
                              </a:s>
                           </a:s>
                           <a:s r="137"> before </a:s>
                           <a:s r="136">
                              <a:s>Today()</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="139" locator="78:3-80:34" xsi:type="Query">
            <source localId="130" locator="78:3-78:11" alias="P">
               <expression localId="129" locator="78:3-78:9" name="Patient" xsi:type="ExpressionRef"/>
            </source>
            <where localId="138" locator="79:5-80:34" xsi:type="Or">
               <operand localId="133" locator="79:11-79:29" xsi:type="IsFalse">
                  <operand asType="t:Boolean" xsi:type="As">
                     <operand localId="132" locator="79:11-79:20" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="deceased" scope="P" xsi:type="Property"/>
                     </operand>
                  </operand>
               </operand>
               <operand localId="137" locator="80:10-80:34" xsi:type="Before">
                  <operand asType="t:DateTime" xsi:type="As">
                     <operand localId="135" locator="80:10-80:19" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="deceased" scope="P" xsi:type="Property"/>
                     </operand>
                  </operand>
                  <operand xsi:type="ToDateTime">
                     <operand localId="136" locator="80:28-80:34" xsi:type="Today"/>
                  </operand>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="155" locator="82:1-85:44" name="TestSlices" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="155">
               <a:s>define TestSlices:
  </a:s>
               <a:s r="154">
                  <a:s>
                     <a:s r="142">
                        <a:s r="141">
                           <a:s r="141">
                              <a:s>[&quot;observation-bp&quot;]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> BP</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="153">
                     <a:s>where </a:s>
                     <a:s r="153">
                        <a:s r="147">
                           <a:s r="145">
                              <a:s r="144">
                                 <a:s r="143">
                                    <a:s>BP</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="144">
                                    <a:s>SystolicBP</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="145">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> &lt; </a:s>
                           <a:s r="146">
                              <a:s>140 'mm[Hg]'</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="152">
                           <a:s r="150">
                              <a:s r="149">
                                 <a:s r="148">
                                    <a:s>BP</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="149">
                                    <a:s>DiastolicBP</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="150">
                                 <a:s>value</a:s>
                              </a:s>
                           </a:s>
                           <a:s> &lt; </a:s>
                           <a:s r="151">
                              <a:s>90 'mm[Hg]'</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="154" locator="83:3-85:44" xsi:type="Query">
            <source localId="142" locator="83:3-83:23" alias="BP">
               <expression localId="141" locator="83:3-83:20" dataType="fhir:Observation" templateId="http://hl7.org/fhir/StructureDefinition/bp" xsi:type="Retrieve"/>
            </source>
            <where localId="153" locator="84:5-85:44" xsi:type="And">
               <operand localId="147" locator="84:11-84:44" xsi:type="Less">
                  <operand asType="t:Quantity" xsi:type="As">
                     <operand localId="145" locator="84:11-84:29" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="value" xsi:type="Property">
                           <source localId="144" locator="84:11-84:23" xsi:type="SingletonFrom">
                              <operand xsi:type="Query">
                                 <source alias="$this">
                                    <expression path="component" xsi:type="Property">
                                       <source name="BP" xsi:type="AliasRef"/>
                                    </expression>
                                 </source>
                                 <where xsi:type="And">
                                    <operand xsi:type="Equal">
                                       <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="system" xsi:type="Property">
                                             <source xsi:type="First">
                                                <source path="coding" xsi:type="Property">
                                                   <source path="code" scope="$this" xsi:type="Property"/>
                                                </source>
                                             </source>
                                          </operand>
                                       </operand>
                                       <operand valueType="t:String" value="http://loinc.org" xsi:type="Literal"/>
                                    </operand>
                                    <operand xsi:type="Equal">
                                       <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="code" xsi:type="Property">
                                             <source xsi:type="First">
                                                <source path="coding" xsi:type="Property">
                                                   <source path="code" scope="$this" xsi:type="Property"/>
                                                </source>
                                             </source>
                                          </operand>
                                       </operand>
                                       <operand valueType="t:String" value="8480-6" xsi:type="Literal"/>
                                    </operand>
                                 </where>
                              </operand>
                           </source>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="146" locator="84:33-84:44" value="140" unit="mm[Hg]" xsi:type="Quantity"/>
               </operand>
               <operand localId="152" locator="85:11-85:44" xsi:type="Less">
                  <operand asType="t:Quantity" xsi:type="As">
                     <operand localId="150" locator="85:11-85:30" name="ToValue" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                        <operand path="value" xsi:type="Property">
                           <source localId="149" locator="85:11-85:24" xsi:type="SingletonFrom">
                              <operand xsi:type="Query">
                                 <source alias="$this">
                                    <expression path="component" xsi:type="Property">
                                       <source name="BP" xsi:type="AliasRef"/>
                                    </expression>
                                 </source>
                                 <where xsi:type="And">
                                    <operand xsi:type="Equal">
                                       <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="system" xsi:type="Property">
                                             <source xsi:type="First">
                                                <source path="coding" xsi:type="Property">
                                                   <source path="code" scope="$this" xsi:type="Property"/>
                                                </source>
                                             </source>
                                          </operand>
                                       </operand>
                                       <operand valueType="t:String" value="http://loinc.org" xsi:type="Literal"/>
                                    </operand>
                                    <operand xsi:type="Equal">
                                       <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                          <operand path="code" xsi:type="Property">
                                             <source xsi:type="First">
                                                <source path="coding" xsi:type="Property">
                                                   <source path="code" scope="$this" xsi:type="Property"/>
                                                </source>
                                             </source>
                                          </operand>
                                       </operand>
                                       <operand valueType="t:String" value="8462-4" xsi:type="Literal"/>
                                    </operand>
                                 </where>
                              </operand>
                           </source>
                        </operand>
                     </operand>
                  </operand>
                  <operand localId="151" locator="85:34-85:44" value="90" unit="mm[Hg]" xsi:type="Quantity"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="163" locator="87:1-89:26" name="TestSimpleExtensions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="163">
               <a:s>define TestSimpleExtensions:
  </a:s>
               <a:s r="162">
                  <a:s>
                     <a:s r="157">
                        <a:s r="156">
                           <a:s>
                              <a:s>Patient</a:s>
                           </a:s>
                        </a:s>
                        <a:s> P</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="161">
                     <a:s>where </a:s>
                     <a:s r="161">
                        <a:s r="159">
                           <a:s r="158">
                              <a:s>P</a:s>
                           </a:s>
                           <a:s>.</a:s>
                           <a:s r="159">
                              <a:s>birthsex</a:s>
                           </a:s>
                        </a:s>
                        <a:s> = </a:s>
                        <a:s r="160">
                           <a:s>'M'</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="162" locator="88:3-89:26" xsi:type="Query">
            <source localId="157" locator="88:3-88:11" alias="P">
               <expression localId="156" locator="88:3-88:9" name="Patient" xsi:type="ExpressionRef"/>
            </source>
            <where localId="161" locator="89:5-89:26" xsi:type="Equal">
               <operand localId="159" locator="89:11-89:20" xsi:type="SingletonFrom">
                  <operand xsi:type="Query">
                     <source alias="$this">
                        <expression path="extension" xsi:type="Property">
                           <source name="P" xsi:type="AliasRef"/>
                        </expression>
                     </source>
                     <where xsi:type="Equal">
                        <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand path="url" scope="$this" xsi:type="Property"/>
                        </operand>
                        <operand valueType="t:String" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex" xsi:type="Literal"/>
                     </where>
                     <return distinct="false">
                        <expression path="value.value" xsi:type="Property">
                           <source name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
               </operand>
               <operand localId="160" locator="89:24-89:26" valueType="t:String" value="M" xsi:type="Literal"/>
            </where>
         </expression>
      </def>
      <def localId="178" locator="91:1-94:50" name="TestComplexExtensions" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="178">
               <a:s>define TestComplexExtensions:
  </a:s>
               <a:s r="177">
                  <a:s>
                     <a:s r="165">
                        <a:s r="164">
                           <a:s>
                              <a:s>Patient</a:s>
                           </a:s>
                        </a:s>
                        <a:s> P</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="176">
                     <a:s>where </a:s>
                     <a:s r="176">
                        <a:s r="170">
                           <a:s r="168">
                              <a:s r="167">
                                 <a:s r="166">
                                    <a:s>P</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="167">
                                    <a:s>race</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="168">
                                 <a:s>ombCategory</a:s>
                              </a:s>
                           </a:s>
                           <a:s> contains </a:s>
                           <a:s r="169">
                              <a:s>&quot;American Indian or Alaska Native&quot;</a:s>
                           </a:s>
                        </a:s>
                        <a:s>
      and </a:s>
                        <a:s r="175">
                           <a:s r="173">
                              <a:s r="172">
                                 <a:s r="171">
                                    <a:s>P</a:s>
                                 </a:s>
                                 <a:s>.</a:s>
                                 <a:s r="172">
                                    <a:s>race</a:s>
                                 </a:s>
                              </a:s>
                              <a:s>.</a:s>
                              <a:s r="173">
                                 <a:s>detailed</a:s>
                              </a:s>
                           </a:s>
                           <a:s> contains </a:s>
                           <a:s r="174">
                              <a:s>&quot;Alaska Native&quot;</a:s>
                           </a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="177" locator="92:3-94:50" xsi:type="Query">
            <source localId="165" locator="92:3-92:11" alias="P">
               <expression localId="164" locator="92:3-92:9" name="Patient" xsi:type="ExpressionRef"/>
            </source>
            <where localId="176" locator="93:5-94:50" xsi:type="And">
               <operand localId="170" locator="93:11-93:72" xsi:type="Contains">
                  <operand localId="168" locator="93:11-93:28" xsi:type="Query">
                     <source alias="$this">
                        <expression xsi:type="Query">
                           <source alias="$this">
                              <expression path="extension" xsi:type="Property">
                                 <source localId="167" locator="93:11-93:16" xsi:type="SingletonFrom">
                                    <operand xsi:type="Query">
                                       <source alias="$this">
                                          <expression path="extension" xsi:type="Property">
                                             <source name="P" xsi:type="AliasRef"/>
                                          </expression>
                                       </source>
                                       <where xsi:type="Equal">
                                          <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="url" scope="$this" xsi:type="Property"/>
                                          </operand>
                                          <operand valueType="t:String" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-race" xsi:type="Literal"/>
                                       </where>
                                    </operand>
                                 </source>
                              </expression>
                           </source>
                           <where xsi:type="Equal">
                              <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="url" scope="$this" xsi:type="Property"/>
                              </operand>
                              <operand valueType="t:String" value="ombCategory" xsi:type="Literal"/>
                           </where>
                           <return distinct="false">
                              <expression path="value" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </return>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToCode" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
                  <operand localId="169" locator="93:39-93:72" name="American Indian or Alaska Native" xsi:type="CodeRef"/>
               </operand>
               <operand localId="175" locator="94:11-94:50" xsi:type="Contains">
                  <operand localId="173" locator="94:11-94:25" xsi:type="Query">
                     <source alias="$this">
                        <expression xsi:type="Query">
                           <source alias="$this">
                              <expression path="extension" xsi:type="Property">
                                 <source localId="172" locator="94:11-94:16" xsi:type="SingletonFrom">
                                    <operand xsi:type="Query">
                                       <source alias="$this">
                                          <expression path="extension" xsi:type="Property">
                                             <source name="P" xsi:type="AliasRef"/>
                                          </expression>
                                       </source>
                                       <where xsi:type="Equal">
                                          <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                             <operand path="url" scope="$this" xsi:type="Property"/>
                                          </operand>
                                          <operand valueType="t:String" value="http://hl7.org/fhir/us/core/StructureDefinition/us-core-race" xsi:type="Literal"/>
                                       </where>
                                    </operand>
                                 </source>
                              </expression>
                           </source>
                           <where xsi:type="Equal">
                              <operand name="ToString" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                                 <operand path="url" scope="$this" xsi:type="Property"/>
                              </operand>
                              <operand valueType="t:String" value="detailed" xsi:type="Literal"/>
                           </where>
                           <return distinct="false">
                              <expression path="value" xsi:type="Property">
                                 <source name="$this" xsi:type="AliasRef"/>
                              </expression>
                           </return>
                        </expression>
                     </source>
                     <return distinct="false">
                        <expression name="ToCode" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                           <operand name="$this" xsi:type="AliasRef"/>
                        </expression>
                     </return>
                  </operand>
                  <operand localId="174" locator="94:36-94:50" name="Alaska Native" xsi:type="CodeRef"/>
               </operand>
            </where>
         </expression>
      </def>
      <def localId="185" locator="96:1-98:19" name="TestComplexFHIRHelpers" context="Patient" accessLevel="Public">
         <annotation xsi:type="a:Annotation">
            <a:s r="185">
               <a:s>define TestComplexFHIRHelpers:
  </a:s>
               <a:s r="184">
                  <a:s>
                     <a:s r="180">
                        <a:s r="179">
                           <a:s r="179">
                              <a:s>[&quot;PediatricBMIforAgeObservationProfile&quot;]</a:s>
                           </a:s>
                        </a:s>
                        <a:s> PB</a:s>
                     </a:s>
                  </a:s>
                  <a:s>
    </a:s>
                  <a:s r="183">
                     <a:s>return </a:s>
                     <a:s r="182">
                        <a:s r="181">
                           <a:s>PB</a:s>
                        </a:s>
                        <a:s>.</a:s>
                        <a:s r="182">
                           <a:s>VSCat</a:s>
                        </a:s>
                     </a:s>
                  </a:s>
               </a:s>
            </a:s>
         </annotation>
         <expression localId="184" locator="97:3-98:19" xsi:type="Query">
            <source localId="180" locator="97:3-97:45" alias="PB">
               <expression localId="179" locator="97:3-97:42" dataType="fhir:Observation" templateId="http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age" xsi:type="Retrieve"/>
            </source>
            <return localId="183" locator="98:5-98:19">
               <expression localId="182" locator="98:12-98:19" name="ToConcept" libraryName="FHIRHelpers" xsi:type="FunctionRef">
                  <operand xsi:type="SingletonFrom">
                     <operand xsi:type="Query">
                        <source alias="$this">
                           <expression path="category" xsi:type="Property">
                              <source name="PB" xsi:type="AliasRef"/>
                           </expression>
                        </source>
                        <where xsi:type="And">
                           <operand xsi:type="Equal">
                              <operand path="system" xsi:type="Property">
                                 <source xsi:type="First">
                                    <source path="coding" scope="$this" xsi:type="Property"/>
                                 </source>
                              </operand>
                              <operand valueType="t:String" value="http://terminology.hl7.org/CodeSystem/observation-category" xsi:type="Literal"/>
                           </operand>
                           <operand xsi:type="Equal">
                              <operand path="code" xsi:type="Property">
                                 <source xsi:type="First">
                                    <source path="coding" scope="$this" xsi:type="Property"/>
                                 </source>
                              </operand>
                              <operand valueType="t:String" value="vital-signs" xsi:type="Literal"/>
                           </operand>
                        </where>
                     </operand>
                  </operand>
               </expression>
            </return>
         </expression>
      </def>
   </statements>
</library>
" + }, { + "contentType": "application/elm+json", + "data": "{
   "library" : {
      "annotation" : [ {
         "translatorVersion" : "2.7.0",
         "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion",
         "type" : "CqlToElmInfo"
      }, {
         "type" : "Annotation",
         "t" : [ {
            "name" : "description",
            "value" : "This is a testing library used to validate capability of the CQL-to-ELM translator\nusing the US Core model info. It is not intended as"
         } ],
         "s" : {
            "r" : "185",
            "s" : [ {
               "value" : [ "/*\n@description: This is a testing library used to validate capability of the CQL-to-ELM translator\nusing the US Core model info. It is not intended as\n*/\n","library USCoreTests version '0.1.0'" ]
            } ]
         }
      } ],
      "identifier" : {
         "id" : "USCoreTests",
         "system" : "http://fhir.org/guides/cqf/us/common",
         "version" : "0.1.0"
      },
      "schemaIdentifier" : {
         "id" : "urn:hl7-org:elm",
         "version" : "r1"
      },
      "usings" : {
         "def" : [ {
            "localIdentifier" : "System",
            "uri" : "urn:hl7-org:elm-types:r1"
         }, {
            "localId" : "1",
            "locator" : "7:1-7:28",
            "localIdentifier" : "USCore",
            "uri" : "http://hl7.org/fhir",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "1",
                  "s" : [ {
                     "value" : [ "","using " ]
                  }, {
                     "s" : [ {
                        "value" : [ "USCore" ]
                     } ]
                  }, {
                     "value" : [ " version ","'3.1.1'" ]
                  } ]
               }
            } ]
         } ]
      },
      "includes" : {
         "def" : [ {
            "localId" : "2",
            "locator" : "9:1-9:37",
            "localIdentifier" : "FHIRHelpers",
            "path" : "http://fhir.org/guides/cqf/us/common/FHIRHelpers",
            "version" : "4.1.000",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "2",
                  "s" : [ {
                     "value" : [ "","include " ]
                  }, {
                     "s" : [ {
                        "value" : [ "FHIRHelpers" ]
                     } ]
                  }, {
                     "value" : [ " version ","'4.1.000'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codeSystems" : {
         "def" : [ {
            "localId" : "3",
            "locator" : "11:1-11:91",
            "name" : "Marital Status Codes",
            "id" : "http://terminology.hl7.org/CodeSystem/v3-MaritalStatus",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "3",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"Marital Status Codes\"",": ","'http://terminology.hl7.org/CodeSystem/v3-MaritalStatus'" ]
                  } ]
               }
            } ]
         }, {
            "localId" : "4",
            "locator" : "12:1-12:76",
            "name" : "CDC Race and Ethnicity Codes",
            "id" : "urn:oid:2.16.840.1.113883.6.238",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "4",
                  "s" : [ {
                     "value" : [ "","codesystem ","\"CDC Race and Ethnicity Codes\"",": ","'urn:oid:2.16.840.1.113883.6.238'" ]
                  } ]
               }
            } ]
         } ]
      },
      "valueSets" : {
         "def" : [ {
            "localId" : "5",
            "locator" : "14:1-14:72",
            "name" : "Marital Status",
            "id" : "http://hl7.org/fhir/ValueSet/marital-status",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "5",
                  "s" : [ {
                     "value" : [ "","valueset ","\"Marital Status\"",": ","'http://hl7.org/fhir/ValueSet/marital-status'" ]
                  } ]
               }
            } ]
         } ]
      },
      "codes" : {
         "def" : [ {
            "localId" : "7",
            "locator" : "16:1-16:64",
            "name" : "Marital Status - Married",
            "id" : "M",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "7",
                  "s" : [ {
                     "value" : [ "","code ","\"Marital Status - Married\"",": ","'M'"," from " ]
                  }, {
                     "r" : "6",
                     "s" : [ {
                        "value" : [ "\"Marital Status Codes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "6",
               "locator" : "16:43-16:64",
               "name" : "Marital Status Codes"
            }
         }, {
            "localId" : "9",
            "locator" : "17:1-17:85",
            "name" : "American Indian or Alaska Native",
            "id" : "1002-5",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "9",
                  "s" : [ {
                     "value" : [ "","code ","\"American Indian or Alaska Native\"",": ","'1002-5'"," from " ]
                  }, {
                     "r" : "8",
                     "s" : [ {
                        "value" : [ "\"CDC Race and Ethnicity Codes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "8",
               "locator" : "17:56-17:85",
               "name" : "CDC Race and Ethnicity Codes"
            }
         }, {
            "localId" : "11",
            "locator" : "18:1-18:66",
            "name" : "Alaska Native",
            "id" : "1735-0",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "11",
                  "s" : [ {
                     "value" : [ "","code ","\"Alaska Native\"",": ","'1735-0'"," from " ]
                  }, {
                     "r" : "10",
                     "s" : [ {
                        "value" : [ "\"CDC Race and Ethnicity Codes\"" ]
                     } ]
                  } ]
               }
            } ],
            "codeSystem" : {
               "localId" : "10",
               "locator" : "18:37-18:66",
               "name" : "CDC Race and Ethnicity Codes"
            }
         } ]
      },
      "contexts" : {
         "def" : [ {
            "locator" : "20:1-20:15",
            "name" : "Patient"
         } ]
      },
      "statements" : {
         "def" : [ {
            "locator" : "20:1-20:15",
            "name" : "Patient",
            "context" : "Patient",
            "expression" : {
               "type" : "SingletonFrom",
               "operand" : {
                  "locator" : "20:1-20:15",
                  "dataType" : "{http://hl7.org/fhir}Patient",
                  "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
                  "type" : "Retrieve"
               }
            }
         }, {
            "localId" : "13",
            "locator" : "22:1-22:38",
            "name" : "TestPatient",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "13",
                  "s" : [ {
                     "value" : [ "","define ","TestPatient",": " ]
                  }, {
                     "r" : "12",
                     "s" : [ {
                        "value" : [ "[","\"PatientProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "12",
               "locator" : "22:21-22:38",
               "dataType" : "{http://hl7.org/fhir}Patient",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "15",
            "locator" : "23:1-23:53",
            "name" : "TestAllergyIntolerance",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "15",
                  "s" : [ {
                     "value" : [ "","define ","TestAllergyIntolerance",": " ]
                  }, {
                     "r" : "14",
                     "s" : [ {
                        "value" : [ "[","\"AllergyIntolerance\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "14",
               "locator" : "23:32-23:53",
               "dataType" : "{http://hl7.org/fhir}AllergyIntolerance",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "17",
            "locator" : "24:1-24:40",
            "name" : "TestCarePlan",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "17",
                  "s" : [ {
                     "value" : [ "","define ","TestCarePlan",": " ]
                  }, {
                     "r" : "16",
                     "s" : [ {
                        "value" : [ "[","\"CarePlanProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "16",
               "locator" : "24:22-24:40",
               "dataType" : "{http://hl7.org/fhir}CarePlan",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-careplan",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "19",
            "locator" : "25:1-25:33",
            "name" : "TestCareTeam",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "19",
                  "s" : [ {
                     "value" : [ "","define ","TestCareTeam",": " ]
                  }, {
                     "r" : "18",
                     "s" : [ {
                        "value" : [ "[","\"CareTeam\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "18",
               "locator" : "25:22-25:33",
               "dataType" : "{http://hl7.org/fhir}CareTeam",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-careteam",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "21",
            "locator" : "26:1-26:35",
            "name" : "TestCondition",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "21",
                  "s" : [ {
                     "value" : [ "","define ","TestCondition",": " ]
                  }, {
                     "r" : "20",
                     "s" : [ {
                        "value" : [ "[","\"Condition\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "20",
               "locator" : "26:23-26:35",
               "dataType" : "{http://hl7.org/fhir}Condition",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "23",
            "locator" : "27:1-27:75",
            "name" : "TestDiagnosticReport",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "23",
                  "s" : [ {
                     "value" : [ "","define ","TestDiagnosticReport",": " ]
                  }, {
                     "r" : "22",
                     "s" : [ {
                        "value" : [ "[","\"DiagnosticReportProfileLaboratoryReporting\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "22",
               "locator" : "27:30-27:75",
               "dataType" : "{http://hl7.org/fhir}DiagnosticReport",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-lab",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "25",
            "locator" : "28:1-28:72",
            "name" : "TestDiagnosticReportNote",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "25",
                  "s" : [ {
                     "value" : [ "","define ","TestDiagnosticReportNote",": " ]
                  }, {
                     "r" : "24",
                     "s" : [ {
                        "value" : [ "[","\"DiagnosticReportProfileNoteExchange\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "24",
               "locator" : "28:34-28:72",
               "dataType" : "{http://hl7.org/fhir}DiagnosticReport",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-diagnosticreport-note",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "27",
            "locator" : "29:1-29:58",
            "name" : "TestDocumentReference",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "27",
                  "s" : [ {
                     "value" : [ "","define ","TestDocumentReference",": " ]
                  }, {
                     "r" : "26",
                     "s" : [ {
                        "value" : [ "[","\"DocumentReferenceProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "26",
               "locator" : "29:31-29:58",
               "dataType" : "{http://hl7.org/fhir}DocumentReference",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-documentreference",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "29",
            "locator" : "30:1-30:42",
            "name" : "TestEncounter",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "29",
                  "s" : [ {
                     "value" : [ "","define ","TestEncounter",": " ]
                  }, {
                     "r" : "28",
                     "s" : [ {
                        "value" : [ "[","\"EncounterProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "28",
               "locator" : "30:23-30:42",
               "dataType" : "{http://hl7.org/fhir}Encounter",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "31",
            "locator" : "31:1-31:32",
            "name" : "TestGoal",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "31",
                  "s" : [ {
                     "value" : [ "","define ","TestGoal",": " ]
                  }, {
                     "r" : "30",
                     "s" : [ {
                        "value" : [ "[","\"GoalProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "30",
               "locator" : "31:18-31:32",
               "dataType" : "{http://hl7.org/fhir}Goal",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-goal",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "33",
            "locator" : "32:1-32:48",
            "name" : "TestImmunization",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "33",
                  "s" : [ {
                     "value" : [ "","define ","TestImmunization",": " ]
                  }, {
                     "r" : "32",
                     "s" : [ {
                        "value" : [ "[","\"ImmunizationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "32",
               "locator" : "32:26-32:48",
               "dataType" : "{http://hl7.org/fhir}Immunization",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-immunization",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "35",
            "locator" : "33:1-33:58",
            "name" : "TestImplantableDevice",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "35",
                  "s" : [ {
                     "value" : [ "","define ","TestImplantableDevice",": " ]
                  }, {
                     "r" : "34",
                     "s" : [ {
                        "value" : [ "[","\"ImplantableDeviceProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "34",
               "locator" : "33:31-33:58",
               "dataType" : "{http://hl7.org/fhir}Device",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "37",
            "locator" : "34:1-34:62",
            "name" : "TestObservation",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "37",
                  "s" : [ {
                     "value" : [ "","define ","TestObservation",": " ]
                  }, {
                     "r" : "36",
                     "s" : [ {
                        "value" : [ "[","\"LaboratoryResultObservationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "36",
               "locator" : "34:25-34:62",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "39",
            "locator" : "35:1-35:33",
            "name" : "TestLocation",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "39",
                  "s" : [ {
                     "value" : [ "","define ","TestLocation",": " ]
                  }, {
                     "r" : "38",
                     "s" : [ {
                        "value" : [ "[","\"Location\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "38",
               "locator" : "35:22-35:33",
               "dataType" : "{http://hl7.org/fhir}Location",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-location",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "41",
            "locator" : "36:1-36:44",
            "name" : "TestMedication",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "41",
                  "s" : [ {
                     "value" : [ "","define ","TestMedication",": " ]
                  }, {
                     "r" : "40",
                     "s" : [ {
                        "value" : [ "[","\"MedicationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "40",
               "locator" : "36:24-36:44",
               "dataType" : "{http://hl7.org/fhir}Medication",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "43",
            "locator" : "37:1-37:58",
            "name" : "TestMedicationRequest",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "43",
                  "s" : [ {
                     "value" : [ "","define ","TestMedicationRequest",": " ]
                  }, {
                     "r" : "42",
                     "s" : [ {
                        "value" : [ "[","\"MedicationRequestProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "42",
               "locator" : "37:31-37:58",
               "dataType" : "{http://hl7.org/fhir}MedicationRequest",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "45",
            "locator" : "38:1-38:48",
            "name" : "TestOrganization",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "45",
                  "s" : [ {
                     "value" : [ "","define ","TestOrganization",": " ]
                  }, {
                     "r" : "44",
                     "s" : [ {
                        "value" : [ "[","\"OrganizationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "44",
               "locator" : "38:26-38:48",
               "dataType" : "{http://hl7.org/fhir}Organization",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-organization",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "47",
            "locator" : "39:1-39:51",
            "name" : "TestVitalsPanel",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "47",
                  "s" : [ {
                     "value" : [ "","define ","TestVitalsPanel",": " ]
                  }, {
                     "r" : "46",
                     "s" : [ {
                        "value" : [ "[","\"observation-vitalspanel\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "46",
               "locator" : "39:25-39:51",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/vitalspanel",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "49",
            "locator" : "40:1-40:66",
            "name" : "TestVitalsPanel2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "49",
                  "s" : [ {
                     "value" : [ "","define ","TestVitalsPanel2",": " ]
                  }, {
                     "r" : "48",
                     "s" : [ {
                        "value" : [ "[","\"Observation Vital Signs Panel Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "48",
               "locator" : "40:26-40:66",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/vitalspanel",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "51",
            "locator" : "41:1-41:45",
            "name" : "TestRespRate",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "51",
                  "s" : [ {
                     "value" : [ "","define ","TestRespRate",": " ]
                  }, {
                     "r" : "50",
                     "s" : [ {
                        "value" : [ "[","\"observation-resprate\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "50",
               "locator" : "41:22-41:45",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/resprate",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "53",
            "locator" : "42:1-42:62",
            "name" : "TestRespRate2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "53",
                  "s" : [ {
                     "value" : [ "","define ","TestRespRate2",": " ]
                  }, {
                     "r" : "52",
                     "s" : [ {
                        "value" : [ "[","\"Observation Respiratory Rate Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "52",
               "locator" : "42:23-42:62",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/resprate",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "55",
            "locator" : "43:1-43:47",
            "name" : "TestHeartRate",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "55",
                  "s" : [ {
                     "value" : [ "","define ","TestHeartRate",": " ]
                  }, {
                     "r" : "54",
                     "s" : [ {
                        "value" : [ "[","\"observation-heartrate\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "54",
               "locator" : "43:23-43:47",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/heartrate",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "57",
            "locator" : "44:1-44:57",
            "name" : "TestHeartRate2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "57",
                  "s" : [ {
                     "value" : [ "","define ","TestHeartRate2",": " ]
                  }, {
                     "r" : "56",
                     "s" : [ {
                        "value" : [ "[","\"Observation Heart Rate Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "56",
               "locator" : "44:24-44:57",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/heartrate",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "59",
            "locator" : "45:1-45:47",
            "name" : "TestOxygenSat",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "59",
                  "s" : [ {
                     "value" : [ "","define ","TestOxygenSat",": " ]
                  }, {
                     "r" : "58",
                     "s" : [ {
                        "value" : [ "[","\"observation-oxygensat\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "58",
               "locator" : "45:23-45:47",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/oxygensat",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "61",
            "locator" : "46:1-46:64",
            "name" : "TestOxygenSat2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "61",
                  "s" : [ {
                     "value" : [ "","define ","TestOxygenSat2",": " ]
                  }, {
                     "r" : "60",
                     "s" : [ {
                        "value" : [ "[","\"Observation Oxygen Saturation Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "60",
               "locator" : "46:24-46:64",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/oxygensat",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "63",
            "locator" : "47:1-47:45",
            "name" : "TestBodyTemp",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "63",
                  "s" : [ {
                     "value" : [ "","define ","TestBodyTemp",": " ]
                  }, {
                     "r" : "62",
                     "s" : [ {
                        "value" : [ "[","\"observation-bodytemp\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "62",
               "locator" : "47:22-47:45",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodytemp",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "65",
            "locator" : "48:1-48:62",
            "name" : "TestBodyTemp2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "65",
                  "s" : [ {
                     "value" : [ "","define ","TestBodyTemp2",": " ]
                  }, {
                     "r" : "64",
                     "s" : [ {
                        "value" : [ "[","\"Observation Body Temperature Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "64",
               "locator" : "48:23-48:62",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodytemp",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "67",
            "locator" : "49:1-49:49",
            "name" : "TestBodyHeight",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "67",
                  "s" : [ {
                     "value" : [ "","define ","TestBodyHeight",": " ]
                  }, {
                     "r" : "66",
                     "s" : [ {
                        "value" : [ "[","\"observation-bodyheight\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "66",
               "locator" : "49:24-49:49",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodyheight",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "69",
            "locator" : "50:1-50:59",
            "name" : "TestBodyHeight2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "69",
                  "s" : [ {
                     "value" : [ "","define ","TestBodyHeight2",": " ]
                  }, {
                     "r" : "68",
                     "s" : [ {
                        "value" : [ "[","\"Observation Body Height Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "68",
               "locator" : "50:25-50:59",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodyheight",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "71",
            "locator" : "51:1-51:49",
            "name" : "TestHeadCircum",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "71",
                  "s" : [ {
                     "value" : [ "","define ","TestHeadCircum",": " ]
                  }, {
                     "r" : "70",
                     "s" : [ {
                        "value" : [ "[","\"observation-headcircum\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "70",
               "locator" : "51:24-51:49",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/headcircum",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "73",
            "locator" : "52:1-52:66",
            "name" : "TestHeadCircum2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "73",
                  "s" : [ {
                     "value" : [ "","define ","TestHeadCircum2",": " ]
                  }, {
                     "r" : "72",
                     "s" : [ {
                        "value" : [ "[","\"Observation Head Circumference Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "72",
               "locator" : "52:25-52:66",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/headcircum",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "75",
            "locator" : "53:1-53:49",
            "name" : "TestBodyWeight",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "75",
                  "s" : [ {
                     "value" : [ "","define ","TestBodyWeight",": " ]
                  }, {
                     "r" : "74",
                     "s" : [ {
                        "value" : [ "[","\"observation-bodyweight\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "74",
               "locator" : "53:24-53:49",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodyweight",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "77",
            "locator" : "54:1-54:59",
            "name" : "TestBodyWeight2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "77",
                  "s" : [ {
                     "value" : [ "","define ","TestBodyWeight2",": " ]
                  }, {
                     "r" : "76",
                     "s" : [ {
                        "value" : [ "[","\"Observation Body Weight Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "76",
               "locator" : "54:25-54:59",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bodyweight",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "79",
            "locator" : "55:1-55:35",
            "name" : "TestBMI",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "79",
                  "s" : [ {
                     "value" : [ "","define ","TestBMI",": " ]
                  }, {
                     "r" : "78",
                     "s" : [ {
                        "value" : [ "[","\"observation-bmi\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "78",
               "locator" : "55:17-55:35",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bmi",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "81",
            "locator" : "56:1-56:56",
            "name" : "TestBMI2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "81",
                  "s" : [ {
                     "value" : [ "","define ","TestBMI2",": " ]
                  }, {
                     "r" : "80",
                     "s" : [ {
                        "value" : [ "[","\"Observation Body Mass Index Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "80",
               "locator" : "56:18-56:56",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bmi",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "83",
            "locator" : "58:1-58:33",
            "name" : "TestBP",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "83",
                  "s" : [ {
                     "value" : [ "","define ","TestBP",": " ]
                  }, {
                     "r" : "82",
                     "s" : [ {
                        "value" : [ "[","\"observation-bp\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "82",
               "locator" : "58:16-58:33",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bp",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "85",
            "locator" : "59:1-59:54",
            "name" : "TestBP2",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "85",
                  "s" : [ {
                     "value" : [ "","define ","TestBP2",": " ]
                  }, {
                     "r" : "84",
                     "s" : [ {
                        "value" : [ "[","\"Observation Blood Pressure Profile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "84",
               "locator" : "59:17-59:54",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/StructureDefinition/bp",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "87",
            "locator" : "60:1-60:50",
            "name" : "TestSmokingStatus",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "87",
                  "s" : [ {
                     "value" : [ "","define ","TestSmokingStatus",": " ]
                  }, {
                     "r" : "86",
                     "s" : [ {
                        "value" : [ "[","\"SmokingStatusProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "86",
               "locator" : "60:27-60:50",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-smokingstatus",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "89",
            "locator" : "61:1-61:50",
            "name" : "TestPulseOximetry",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "89",
                  "s" : [ {
                     "value" : [ "","define ","TestPulseOximetry",": " ]
                  }, {
                     "r" : "88",
                     "s" : [ {
                        "value" : [ "[","\"PulseOximetryProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "88",
               "locator" : "61:27-61:50",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-pulse-oximetry",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "91",
            "locator" : "62:1-62:71",
            "name" : "TestPediatricBMIForAge",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "91",
                  "s" : [ {
                     "value" : [ "","define ","TestPediatricBMIForAge",": " ]
                  }, {
                     "r" : "90",
                     "s" : [ {
                        "value" : [ "[","\"PediatricBMIforAgeObservationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "90",
               "locator" : "62:32-62:71",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "93",
            "locator" : "63:1-63:83",
            "name" : "TestPediatricWeightForHeight",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "93",
                  "s" : [ {
                     "value" : [ "","define ","TestPediatricWeightForHeight",": " ]
                  }, {
                     "r" : "92",
                     "s" : [ {
                        "value" : [ "[","\"PediatricWeightForHeightObservationProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "92",
               "locator" : "63:38-63:83",
               "dataType" : "{http://hl7.org/fhir}Observation",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-weight-for-height",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "95",
            "locator" : "64:1-64:48",
            "name" : "TestPractitioner",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "95",
                  "s" : [ {
                     "value" : [ "","define ","TestPractitioner",": " ]
                  }, {
                     "r" : "94",
                     "s" : [ {
                        "value" : [ "[","\"PractitionerProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "94",
               "locator" : "64:26-64:48",
               "dataType" : "{http://hl7.org/fhir}Practitioner",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitioner",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "97",
            "locator" : "65:1-65:56",
            "name" : "TestPractitionerRole",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "97",
                  "s" : [ {
                     "value" : [ "","define ","TestPractitionerRole",": " ]
                  }, {
                     "r" : "96",
                     "s" : [ {
                        "value" : [ "[","\"PractitionerRoleProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "96",
               "locator" : "65:30-65:56",
               "dataType" : "{http://hl7.org/fhir}PractitionerRole",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitionerrole",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "99",
            "locator" : "66:1-66:42",
            "name" : "TestProcedure",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "99",
                  "s" : [ {
                     "value" : [ "","define ","TestProcedure",": " ]
                  }, {
                     "r" : "98",
                     "s" : [ {
                        "value" : [ "[","\"ProcedureProfile\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "98",
               "locator" : "66:23-66:42",
               "dataType" : "{http://hl7.org/fhir}Procedure",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-procedure",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "101",
            "locator" : "67:1-67:37",
            "name" : "TestProvenance",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "101",
                  "s" : [ {
                     "value" : [ "","define ","TestProvenance",": " ]
                  }, {
                     "r" : "100",
                     "s" : [ {
                        "value" : [ "[","\"Provenance\"","]" ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "100",
               "locator" : "67:24-67:37",
               "dataType" : "{http://hl7.org/fhir}Provenance",
               "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-provenance",
               "type" : "Retrieve"
            }
         }, {
            "localId" : "128",
            "locator" : "69:1-75:54",
            "name" : "TestPrimitives",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "128",
                  "s" : [ {
                     "value" : [ "","define ","TestPrimitives",":\n  " ]
                  }, {
                     "r" : "127",
                     "s" : [ {
                        "s" : [ {
                           "r" : "103",
                           "s" : [ {
                              "r" : "102",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","P" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "126",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "126",
                           "s" : [ {
                              "r" : "121",
                              "s" : [ {
                                 "r" : "116",
                                 "s" : [ {
                                    "r" : "111",
                                    "s" : [ {
                                       "r" : "107",
                                       "s" : [ {
                                          "r" : "105",
                                          "s" : [ {
                                             "r" : "104",
                                             "s" : [ {
                                                "value" : [ "P" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "105",
                                             "s" : [ {
                                                "value" : [ "gender" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " ","="," " ]
                                       }, {
                                          "r" : "106",
                                          "s" : [ {
                                             "value" : [ "'male'" ]
                                          } ]
                                       } ]
                                    }, {
                                       "value" : [ "\n      and " ]
                                    }, {
                                       "r" : "110",
                                       "s" : [ {
                                          "r" : "109",
                                          "s" : [ {
                                             "r" : "108",
                                             "s" : [ {
                                                "value" : [ "P" ]
                                             } ]
                                          }, {
                                             "value" : [ "." ]
                                          }, {
                                             "r" : "109",
                                             "s" : [ {
                                                "value" : [ "active" ]
                                             } ]
                                          } ]
                                       }, {
                                          "value" : [ " is true" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "\n      and " ]
                                 }, {
                                    "r" : "115",
                                    "s" : [ {
                                       "r" : "113",
                                       "s" : [ {
                                          "r" : "112",
                                          "s" : [ {
                                             "value" : [ "P" ]
                                          } ]
                                       }, {
                                          "value" : [ "." ]
                                       }, {
                                          "r" : "113",
                                          "s" : [ {
                                             "value" : [ "birthDate" ]
                                          } ]
                                       } ]
                                    }, {
                                       "r" : "115",
                                       "value" : [ " ","before"," " ]
                                    }, {
                                       "r" : "114",
                                       "s" : [ {
                                          "value" : [ "Today","()" ]
                                       } ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ "\n      and " ]
                              }, {
                                 "r" : "120",
                                 "s" : [ {
                                    "r" : "118",
                                    "s" : [ {
                                       "r" : "117",
                                       "s" : [ {
                                          "value" : [ "P" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "118",
                                       "s" : [ {
                                          "value" : [ "maritalStatus" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ " in " ]
                                 }, {
                                    "r" : "119",
                                    "s" : [ {
                                       "value" : [ "\"Marital Status\"" ]
                                    } ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "125",
                              "s" : [ {
                                 "r" : "123",
                                 "s" : [ {
                                    "r" : "122",
                                    "s" : [ {
                                       "value" : [ "P" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "123",
                                    "s" : [ {
                                       "value" : [ "maritalStatus" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","~"," " ]
                              }, {
                                 "r" : "124",
                                 "s" : [ {
                                    "value" : [ "\"Marital Status - Married\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "127",
               "locator" : "70:3-75:54",
               "type" : "Query",
               "source" : [ {
                  "localId" : "103",
                  "locator" : "70:3-70:11",
                  "alias" : "P",
                  "expression" : {
                     "localId" : "102",
                     "locator" : "70:3-70:9",
                     "name" : "Patient",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "126",
                  "locator" : "71:5-75:54",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "121",
                     "locator" : "71:11-74:45",
                     "type" : "And",
                     "operand" : [ {
                        "localId" : "116",
                        "locator" : "71:11-73:36",
                        "type" : "And",
                        "operand" : [ {
                           "localId" : "111",
                           "locator" : "71:11-72:26",
                           "type" : "And",
                           "operand" : [ {
                              "localId" : "107",
                              "locator" : "71:11-71:27",
                              "type" : "Equal",
                              "operand" : [ {
                                 "localId" : "105",
                                 "locator" : "71:11-71:18",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "path" : "gender",
                                    "scope" : "P",
                                    "type" : "Property"
                                 }
                              }, {
                                 "localId" : "106",
                                 "locator" : "71:22-71:27",
                                 "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                 "value" : "male",
                                 "type" : "Literal"
                              } ]
                           }, {
                              "localId" : "110",
                              "locator" : "72:11-72:26",
                              "type" : "IsTrue",
                              "operand" : {
                                 "localId" : "109",
                                 "locator" : "72:11-72:18",
                                 "path" : "value",
                                 "type" : "Property",
                                 "source" : {
                                    "path" : "active",
                                    "scope" : "P",
                                    "type" : "Property"
                                 }
                              }
                           } ]
                        }, {
                           "localId" : "115",
                           "locator" : "73:11-73:36",
                           "type" : "Before",
                           "operand" : [ {
                              "localId" : "113",
                              "locator" : "73:11-73:21",
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "path" : "birthDate",
                                 "scope" : "P",
                                 "type" : "Property"
                              }
                           }, {
                              "localId" : "114",
                              "locator" : "73:30-73:36",
                              "type" : "Today"
                           } ]
                        } ]
                     }, {
                        "localId" : "120",
                        "locator" : "74:11-74:45",
                        "type" : "InValueSet",
                        "code" : {
                           "localId" : "118",
                           "locator" : "74:11-74:25",
                           "name" : "ToConcept",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "maritalStatus",
                              "scope" : "P",
                              "type" : "Property"
                           } ]
                        },
                        "valueset" : {
                           "localId" : "119",
                           "locator" : "74:30-74:45",
                           "name" : "Marital Status",
                           "preserve" : true
                        }
                     } ]
                  }, {
                     "localId" : "125",
                     "locator" : "75:11-75:54",
                     "type" : "Equivalent",
                     "operand" : [ {
                        "localId" : "123",
                        "locator" : "75:11-75:25",
                        "name" : "ToConcept",
                        "libraryName" : "FHIRHelpers",
                        "type" : "FunctionRef",
                        "operand" : [ {
                           "path" : "maritalStatus",
                           "scope" : "P",
                           "type" : "Property"
                        } ]
                     }, {
                        "type" : "ToConcept",
                        "operand" : {
                           "localId" : "124",
                           "locator" : "75:29-75:54",
                           "name" : "Marital Status - Married",
                           "type" : "CodeRef"
                        }
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "140",
            "locator" : "77:1-80:34",
            "name" : "TestChoice",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "140",
                  "s" : [ {
                     "value" : [ "","define ","TestChoice",":\n  " ]
                  }, {
                     "r" : "139",
                     "s" : [ {
                        "s" : [ {
                           "r" : "130",
                           "s" : [ {
                              "r" : "129",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","P" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "138",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "138",
                           "s" : [ {
                              "r" : "133",
                              "s" : [ {
                                 "r" : "132",
                                 "s" : [ {
                                    "r" : "131",
                                    "s" : [ {
                                       "value" : [ "P" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "132",
                                    "s" : [ {
                                       "value" : [ "deceased" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " is false" ]
                              } ]
                           }, {
                              "value" : [ "\n      or " ]
                           }, {
                              "r" : "137",
                              "s" : [ {
                                 "r" : "135",
                                 "s" : [ {
                                    "r" : "134",
                                    "s" : [ {
                                       "value" : [ "P" ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "135",
                                    "s" : [ {
                                       "value" : [ "deceased" ]
                                    } ]
                                 } ]
                              }, {
                                 "r" : "137",
                                 "value" : [ " ","before"," " ]
                              }, {
                                 "r" : "136",
                                 "s" : [ {
                                    "value" : [ "Today","()" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "139",
               "locator" : "78:3-80:34",
               "type" : "Query",
               "source" : [ {
                  "localId" : "130",
                  "locator" : "78:3-78:11",
                  "alias" : "P",
                  "expression" : {
                     "localId" : "129",
                     "locator" : "78:3-78:9",
                     "name" : "Patient",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "138",
                  "locator" : "79:5-80:34",
                  "type" : "Or",
                  "operand" : [ {
                     "localId" : "133",
                     "locator" : "79:11-79:29",
                     "type" : "IsFalse",
                     "operand" : {
                        "asType" : "{urn:hl7-org:elm-types:r1}Boolean",
                        "type" : "As",
                        "operand" : {
                           "localId" : "132",
                           "locator" : "79:11-79:20",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "deceased",
                              "scope" : "P",
                              "type" : "Property"
                           } ]
                        }
                     }
                  }, {
                     "localId" : "137",
                     "locator" : "80:10-80:34",
                     "type" : "Before",
                     "operand" : [ {
                        "asType" : "{urn:hl7-org:elm-types:r1}DateTime",
                        "type" : "As",
                        "operand" : {
                           "localId" : "135",
                           "locator" : "80:10-80:19",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "deceased",
                              "scope" : "P",
                              "type" : "Property"
                           } ]
                        }
                     }, {
                        "type" : "ToDateTime",
                        "operand" : {
                           "localId" : "136",
                           "locator" : "80:28-80:34",
                           "type" : "Today"
                        }
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "155",
            "locator" : "82:1-85:44",
            "name" : "TestSlices",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "155",
                  "s" : [ {
                     "value" : [ "","define ","TestSlices",":\n  " ]
                  }, {
                     "r" : "154",
                     "s" : [ {
                        "s" : [ {
                           "r" : "142",
                           "s" : [ {
                              "r" : "141",
                              "s" : [ {
                                 "r" : "141",
                                 "s" : [ {
                                    "value" : [ "[","\"observation-bp\"","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","BP" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "153",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "153",
                           "s" : [ {
                              "r" : "147",
                              "s" : [ {
                                 "r" : "145",
                                 "s" : [ {
                                    "r" : "144",
                                    "s" : [ {
                                       "r" : "143",
                                       "s" : [ {
                                          "value" : [ "BP" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "144",
                                       "s" : [ {
                                          "value" : [ "SystolicBP" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "145",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","<"," " ]
                              }, {
                                 "r" : "146",
                                 "s" : [ {
                                    "value" : [ "140 ","'mm[Hg]'" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "152",
                              "s" : [ {
                                 "r" : "150",
                                 "s" : [ {
                                    "r" : "149",
                                    "s" : [ {
                                       "r" : "148",
                                       "s" : [ {
                                          "value" : [ "BP" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "149",
                                       "s" : [ {
                                          "value" : [ "DiastolicBP" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "150",
                                    "s" : [ {
                                       "value" : [ "value" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " ","<"," " ]
                              }, {
                                 "r" : "151",
                                 "s" : [ {
                                    "value" : [ "90 ","'mm[Hg]'" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "154",
               "locator" : "83:3-85:44",
               "type" : "Query",
               "source" : [ {
                  "localId" : "142",
                  "locator" : "83:3-83:23",
                  "alias" : "BP",
                  "expression" : {
                     "localId" : "141",
                     "locator" : "83:3-83:20",
                     "dataType" : "{http://hl7.org/fhir}Observation",
                     "templateId" : "http://hl7.org/fhir/StructureDefinition/bp",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "153",
                  "locator" : "84:5-85:44",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "147",
                     "locator" : "84:11-84:44",
                     "type" : "Less",
                     "operand" : [ {
                        "asType" : "{urn:hl7-org:elm-types:r1}Quantity",
                        "type" : "As",
                        "operand" : {
                           "localId" : "145",
                           "locator" : "84:11-84:29",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "144",
                                 "locator" : "84:11-84:23",
                                 "type" : "SingletonFrom",
                                 "operand" : {
                                    "type" : "Query",
                                    "source" : [ {
                                       "alias" : "$this",
                                       "expression" : {
                                          "path" : "component",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "BP",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    } ],
                                    "where" : {
                                       "type" : "And",
                                       "operand" : [ {
                                          "type" : "Equal",
                                          "operand" : [ {
                                             "name" : "ToString",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "system",
                                                "type" : "Property",
                                                "source" : {
                                                   "type" : "First",
                                                   "source" : {
                                                      "path" : "coding",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "code",
                                                         "scope" : "$this",
                                                         "type" : "Property"
                                                      }
                                                   }
                                                }
                                             } ]
                                          }, {
                                             "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                             "value" : "http://loinc.org",
                                             "type" : "Literal"
                                          } ]
                                       }, {
                                          "type" : "Equal",
                                          "operand" : [ {
                                             "name" : "ToString",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "code",
                                                "type" : "Property",
                                                "source" : {
                                                   "type" : "First",
                                                   "source" : {
                                                      "path" : "coding",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "code",
                                                         "scope" : "$this",
                                                         "type" : "Property"
                                                      }
                                                   }
                                                }
                                             } ]
                                          }, {
                                             "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                             "value" : "8480-6",
                                             "type" : "Literal"
                                          } ]
                                       } ]
                                    }
                                 }
                              }
                           } ]
                        }
                     }, {
                        "localId" : "146",
                        "locator" : "84:33-84:44",
                        "value" : 140,
                        "unit" : "mm[Hg]",
                        "type" : "Quantity"
                     } ]
                  }, {
                     "localId" : "152",
                     "locator" : "85:11-85:44",
                     "type" : "Less",
                     "operand" : [ {
                        "asType" : "{urn:hl7-org:elm-types:r1}Quantity",
                        "type" : "As",
                        "operand" : {
                           "localId" : "150",
                           "locator" : "85:11-85:30",
                           "name" : "ToValue",
                           "libraryName" : "FHIRHelpers",
                           "type" : "FunctionRef",
                           "operand" : [ {
                              "path" : "value",
                              "type" : "Property",
                              "source" : {
                                 "localId" : "149",
                                 "locator" : "85:11-85:24",
                                 "type" : "SingletonFrom",
                                 "operand" : {
                                    "type" : "Query",
                                    "source" : [ {
                                       "alias" : "$this",
                                       "expression" : {
                                          "path" : "component",
                                          "type" : "Property",
                                          "source" : {
                                             "name" : "BP",
                                             "type" : "AliasRef"
                                          }
                                       }
                                    } ],
                                    "where" : {
                                       "type" : "And",
                                       "operand" : [ {
                                          "type" : "Equal",
                                          "operand" : [ {
                                             "name" : "ToString",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "system",
                                                "type" : "Property",
                                                "source" : {
                                                   "type" : "First",
                                                   "source" : {
                                                      "path" : "coding",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "code",
                                                         "scope" : "$this",
                                                         "type" : "Property"
                                                      }
                                                   }
                                                }
                                             } ]
                                          }, {
                                             "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                             "value" : "http://loinc.org",
                                             "type" : "Literal"
                                          } ]
                                       }, {
                                          "type" : "Equal",
                                          "operand" : [ {
                                             "name" : "ToString",
                                             "libraryName" : "FHIRHelpers",
                                             "type" : "FunctionRef",
                                             "operand" : [ {
                                                "path" : "code",
                                                "type" : "Property",
                                                "source" : {
                                                   "type" : "First",
                                                   "source" : {
                                                      "path" : "coding",
                                                      "type" : "Property",
                                                      "source" : {
                                                         "path" : "code",
                                                         "scope" : "$this",
                                                         "type" : "Property"
                                                      }
                                                   }
                                                }
                                             } ]
                                          }, {
                                             "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                             "value" : "8462-4",
                                             "type" : "Literal"
                                          } ]
                                       } ]
                                    }
                                 }
                              }
                           } ]
                        }
                     }, {
                        "localId" : "151",
                        "locator" : "85:34-85:44",
                        "value" : 90,
                        "unit" : "mm[Hg]",
                        "type" : "Quantity"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "163",
            "locator" : "87:1-89:26",
            "name" : "TestSimpleExtensions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "163",
                  "s" : [ {
                     "value" : [ "","define ","TestSimpleExtensions",":\n  " ]
                  }, {
                     "r" : "162",
                     "s" : [ {
                        "s" : [ {
                           "r" : "157",
                           "s" : [ {
                              "r" : "156",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","P" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "161",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "161",
                           "s" : [ {
                              "r" : "159",
                              "s" : [ {
                                 "r" : "158",
                                 "s" : [ {
                                    "value" : [ "P" ]
                                 } ]
                              }, {
                                 "value" : [ "." ]
                              }, {
                                 "r" : "159",
                                 "s" : [ {
                                    "value" : [ "birthsex" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","="," " ]
                           }, {
                              "r" : "160",
                              "s" : [ {
                                 "value" : [ "'M'" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "162",
               "locator" : "88:3-89:26",
               "type" : "Query",
               "source" : [ {
                  "localId" : "157",
                  "locator" : "88:3-88:11",
                  "alias" : "P",
                  "expression" : {
                     "localId" : "156",
                     "locator" : "88:3-88:9",
                     "name" : "Patient",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "161",
                  "locator" : "89:5-89:26",
                  "type" : "Equal",
                  "operand" : [ {
                     "localId" : "159",
                     "locator" : "89:11-89:20",
                     "type" : "SingletonFrom",
                     "operand" : {
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "path" : "extension",
                              "type" : "Property",
                              "source" : {
                                 "name" : "P",
                                 "type" : "AliasRef"
                              }
                           }
                        } ],
                        "where" : {
                           "type" : "Equal",
                           "operand" : [ {
                              "name" : "ToString",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "path" : "url",
                                 "scope" : "$this",
                                 "type" : "Property"
                              } ]
                           }, {
                              "valueType" : "{urn:hl7-org:elm-types:r1}String",
                              "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex",
                              "type" : "Literal"
                           } ]
                        },
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "path" : "value.value",
                              "type" : "Property",
                              "source" : {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              }
                           }
                        }
                     }
                  }, {
                     "localId" : "160",
                     "locator" : "89:24-89:26",
                     "valueType" : "{urn:hl7-org:elm-types:r1}String",
                     "value" : "M",
                     "type" : "Literal"
                  } ]
               }
            }
         }, {
            "localId" : "178",
            "locator" : "91:1-94:50",
            "name" : "TestComplexExtensions",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "178",
                  "s" : [ {
                     "value" : [ "","define ","TestComplexExtensions",":\n  " ]
                  }, {
                     "r" : "177",
                     "s" : [ {
                        "s" : [ {
                           "r" : "165",
                           "s" : [ {
                              "r" : "164",
                              "s" : [ {
                                 "s" : [ {
                                    "value" : [ "Patient" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","P" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "176",
                        "s" : [ {
                           "value" : [ "where " ]
                        }, {
                           "r" : "176",
                           "s" : [ {
                              "r" : "170",
                              "s" : [ {
                                 "r" : "168",
                                 "s" : [ {
                                    "r" : "167",
                                    "s" : [ {
                                       "r" : "166",
                                       "s" : [ {
                                          "value" : [ "P" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "167",
                                       "s" : [ {
                                          "value" : [ "race" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "168",
                                    "s" : [ {
                                       "value" : [ "ombCategory" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " contains " ]
                              }, {
                                 "r" : "169",
                                 "s" : [ {
                                    "value" : [ "\"American Indian or Alaska Native\"" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ "\n      and " ]
                           }, {
                              "r" : "175",
                              "s" : [ {
                                 "r" : "173",
                                 "s" : [ {
                                    "r" : "172",
                                    "s" : [ {
                                       "r" : "171",
                                       "s" : [ {
                                          "value" : [ "P" ]
                                       } ]
                                    }, {
                                       "value" : [ "." ]
                                    }, {
                                       "r" : "172",
                                       "s" : [ {
                                          "value" : [ "race" ]
                                       } ]
                                    } ]
                                 }, {
                                    "value" : [ "." ]
                                 }, {
                                    "r" : "173",
                                    "s" : [ {
                                       "value" : [ "detailed" ]
                                    } ]
                                 } ]
                              }, {
                                 "value" : [ " contains " ]
                              }, {
                                 "r" : "174",
                                 "s" : [ {
                                    "value" : [ "\"Alaska Native\"" ]
                                 } ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "177",
               "locator" : "92:3-94:50",
               "type" : "Query",
               "source" : [ {
                  "localId" : "165",
                  "locator" : "92:3-92:11",
                  "alias" : "P",
                  "expression" : {
                     "localId" : "164",
                     "locator" : "92:3-92:9",
                     "name" : "Patient",
                     "type" : "ExpressionRef"
                  }
               } ],
               "relationship" : [ ],
               "where" : {
                  "localId" : "176",
                  "locator" : "93:5-94:50",
                  "type" : "And",
                  "operand" : [ {
                     "localId" : "170",
                     "locator" : "93:11-93:72",
                     "type" : "Contains",
                     "operand" : [ {
                        "localId" : "168",
                        "locator" : "93:11-93:28",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "path" : "extension",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "167",
                                       "locator" : "93:11-93:16",
                                       "type" : "SingletonFrom",
                                       "operand" : {
                                          "type" : "Query",
                                          "source" : [ {
                                             "alias" : "$this",
                                             "expression" : {
                                                "path" : "extension",
                                                "type" : "Property",
                                                "source" : {
                                                   "name" : "P",
                                                   "type" : "AliasRef"
                                                }
                                             }
                                          } ],
                                          "where" : {
                                             "type" : "Equal",
                                             "operand" : [ {
                                                "name" : "ToString",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "url",
                                                   "scope" : "$this",
                                                   "type" : "Property"
                                                } ]
                                             }, {
                                                "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                                "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race",
                                                "type" : "Literal"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              } ],
                              "where" : {
                                 "type" : "Equal",
                                 "operand" : [ {
                                    "name" : "ToString",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "url",
                                       "scope" : "$this",
                                       "type" : "Property"
                                    } ]
                                 }, {
                                    "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                    "value" : "ombCategory",
                                    "type" : "Literal"
                                 } ]
                              },
                              "return" : {
                                 "distinct" : false,
                                 "expression" : {
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToCode",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }, {
                        "localId" : "169",
                        "locator" : "93:39-93:72",
                        "name" : "American Indian or Alaska Native",
                        "type" : "CodeRef"
                     } ]
                  }, {
                     "localId" : "175",
                     "locator" : "94:11-94:50",
                     "type" : "Contains",
                     "operand" : [ {
                        "localId" : "173",
                        "locator" : "94:11-94:25",
                        "type" : "Query",
                        "source" : [ {
                           "alias" : "$this",
                           "expression" : {
                              "type" : "Query",
                              "source" : [ {
                                 "alias" : "$this",
                                 "expression" : {
                                    "path" : "extension",
                                    "type" : "Property",
                                    "source" : {
                                       "localId" : "172",
                                       "locator" : "94:11-94:16",
                                       "type" : "SingletonFrom",
                                       "operand" : {
                                          "type" : "Query",
                                          "source" : [ {
                                             "alias" : "$this",
                                             "expression" : {
                                                "path" : "extension",
                                                "type" : "Property",
                                                "source" : {
                                                   "name" : "P",
                                                   "type" : "AliasRef"
                                                }
                                             }
                                          } ],
                                          "where" : {
                                             "type" : "Equal",
                                             "operand" : [ {
                                                "name" : "ToString",
                                                "libraryName" : "FHIRHelpers",
                                                "type" : "FunctionRef",
                                                "operand" : [ {
                                                   "path" : "url",
                                                   "scope" : "$this",
                                                   "type" : "Property"
                                                } ]
                                             }, {
                                                "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                                "value" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race",
                                                "type" : "Literal"
                                             } ]
                                          }
                                       }
                                    }
                                 }
                              } ],
                              "where" : {
                                 "type" : "Equal",
                                 "operand" : [ {
                                    "name" : "ToString",
                                    "libraryName" : "FHIRHelpers",
                                    "type" : "FunctionRef",
                                    "operand" : [ {
                                       "path" : "url",
                                       "scope" : "$this",
                                       "type" : "Property"
                                    } ]
                                 }, {
                                    "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                    "value" : "detailed",
                                    "type" : "Literal"
                                 } ]
                              },
                              "return" : {
                                 "distinct" : false,
                                 "expression" : {
                                    "path" : "value",
                                    "type" : "Property",
                                    "source" : {
                                       "name" : "$this",
                                       "type" : "AliasRef"
                                    }
                                 }
                              }
                           }
                        } ],
                        "return" : {
                           "distinct" : false,
                           "expression" : {
                              "name" : "ToCode",
                              "libraryName" : "FHIRHelpers",
                              "type" : "FunctionRef",
                              "operand" : [ {
                                 "name" : "$this",
                                 "type" : "AliasRef"
                              } ]
                           }
                        }
                     }, {
                        "localId" : "174",
                        "locator" : "94:36-94:50",
                        "name" : "Alaska Native",
                        "type" : "CodeRef"
                     } ]
                  } ]
               }
            }
         }, {
            "localId" : "185",
            "locator" : "96:1-98:19",
            "name" : "TestComplexFHIRHelpers",
            "context" : "Patient",
            "accessLevel" : "Public",
            "annotation" : [ {
               "type" : "Annotation",
               "s" : {
                  "r" : "185",
                  "s" : [ {
                     "value" : [ "","define ","TestComplexFHIRHelpers",":\n  " ]
                  }, {
                     "r" : "184",
                     "s" : [ {
                        "s" : [ {
                           "r" : "180",
                           "s" : [ {
                              "r" : "179",
                              "s" : [ {
                                 "r" : "179",
                                 "s" : [ {
                                    "value" : [ "[","\"PediatricBMIforAgeObservationProfile\"","]" ]
                                 } ]
                              } ]
                           }, {
                              "value" : [ " ","PB" ]
                           } ]
                        } ]
                     }, {
                        "value" : [ "\n    " ]
                     }, {
                        "r" : "183",
                        "s" : [ {
                           "value" : [ "return " ]
                        }, {
                           "r" : "182",
                           "s" : [ {
                              "r" : "181",
                              "s" : [ {
                                 "value" : [ "PB" ]
                              } ]
                           }, {
                              "value" : [ "." ]
                           }, {
                              "r" : "182",
                              "s" : [ {
                                 "value" : [ "VSCat" ]
                              } ]
                           } ]
                        } ]
                     } ]
                  } ]
               }
            } ],
            "expression" : {
               "localId" : "184",
               "locator" : "97:3-98:19",
               "type" : "Query",
               "source" : [ {
                  "localId" : "180",
                  "locator" : "97:3-97:45",
                  "alias" : "PB",
                  "expression" : {
                     "localId" : "179",
                     "locator" : "97:3-97:42",
                     "dataType" : "{http://hl7.org/fhir}Observation",
                     "templateId" : "http://hl7.org/fhir/us/core/StructureDefinition/pediatric-bmi-for-age",
                     "type" : "Retrieve"
                  }
               } ],
               "relationship" : [ ],
               "return" : {
                  "localId" : "183",
                  "locator" : "98:5-98:19",
                  "expression" : {
                     "localId" : "182",
                     "locator" : "98:12-98:19",
                     "name" : "ToConcept",
                     "libraryName" : "FHIRHelpers",
                     "type" : "FunctionRef",
                     "operand" : [ {
                        "type" : "SingletonFrom",
                        "operand" : {
                           "type" : "Query",
                           "source" : [ {
                              "alias" : "$this",
                              "expression" : {
                                 "path" : "category",
                                 "type" : "Property",
                                 "source" : {
                                    "name" : "PB",
                                    "type" : "AliasRef"
                                 }
                              }
                           } ],
                           "where" : {
                              "type" : "And",
                              "operand" : [ {
                                 "type" : "Equal",
                                 "operand" : [ {
                                    "path" : "system",
                                    "type" : "Property",
                                    "source" : {
                                       "type" : "First",
                                       "source" : {
                                          "path" : "coding",
                                          "scope" : "$this",
                                          "type" : "Property"
                                       }
                                    }
                                 }, {
                                    "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                    "value" : "http://terminology.hl7.org/CodeSystem/observation-category",
                                    "type" : "Literal"
                                 } ]
                              }, {
                                 "type" : "Equal",
                                 "operand" : [ {
                                    "path" : "code",
                                    "type" : "Property",
                                    "source" : {
                                       "type" : "First",
                                       "source" : {
                                          "path" : "coding",
                                          "scope" : "$this",
                                          "type" : "Property"
                                       }
                                    }
                                 }, {
                                    "valueType" : "{urn:hl7-org:elm-types:r1}String",
                                    "value" : "vital-signs",
                                    "type" : "Literal"
                                 } ]
                              } ]
                           }
                        }
                     } ]
                  }
               }
            }
         } ]
      }
   }
}" + } ] +} \ No newline at end of file